// ThreeWebGL.js r39 - http://github.com/mrdoob/three.js
var THREE = THREE || {};
if(!window.Int32Array) {
	window.Int32Array = Array;
	window.Float32Array = Array
}
THREE.Color = function(b) {
	this.setHex(b)
};
THREE.Color.prototype = {
	autoUpdate: !0,
	copy: function(b) {
		this.r = b.r;
		this.g = b.g;
		this.b = b.b;
		this.hex = b.hex;
		this.__styleString = b.__styleString
	},
	setRGB: function(b, d, e) {
		this.r = b;
		this.g = d;
		this.b = e;
		if(this.autoUpdate) {
			this.updateHex();
			this.updateStyleString()
		}
	},
	setHSV: function(b, d, e) {
		var g, h, o, n, p, q;
		if(e == 0) g = h = o = 0;
		else {
			n = Math.floor(b * 6);
			p = b * 6 - n;
			b = e * (1 - d);
			q = e * (1 - d * p);
			d = e * (1 - d * (1 - p));
			switch(n) {
				case 1:
					g = q;
					h = e;
					o = b;
					break;
				case 2:
					g = b;
					h = e;
					o = d;
					break;
				case 3:
					g = b;
					h = q;
					o = e;
					break;
				case 4:
					g = d;
					h = b;
					o = e;
					break;
				case 5:
					g = e;
					h = b;
					o = q;
					break;
				case 6:
				case 0:
					g = e;
					h = d;
					o = b
			}
		}
		this.r = g;
		this.g = h;
		this.b = o;
		if(this.autoUpdate) {
			this.updateHex();
			this.updateStyleString()
		}
	},
	setHex: function(b) {
		this.hex = ~~b & 16777215;
		if(this.autoUpdate) {
			this.updateRGB();
			this.updateStyleString()
		}
	},
	updateHex: function() {
		this.hex = ~~(this.r * 255) << 16 ^ ~~(this.g * 255) << 8 ^ ~~(this.b * 255)
	},
	updateRGB: function() {
		this.r = (this.hex >> 16 & 255) / 255;
		this.g = (this.hex >> 8 & 255) / 255;
		this.b = (this.hex & 255) / 255
	},
	updateStyleString: function() {
		this.__styleString = "rgb(" + ~~(this.r * 255) + "," + ~~(this.g *
			255) + "," + ~~(this.b * 255) + ")"
	},
	clone: function() {
		return new THREE.Color(this.hex)
	}
};
THREE.Vector2 = function(b, d) {
	this.set(b || 0, d || 0)
};
THREE.Vector2.prototype = {
	set: function(b, d) {
		this.x = b;
		this.y = d;
		return this
	},
	copy: function(b) {
		this.set(b.x, b.y);
		return this
	},
	addSelf: function(b) {
		this.set(this.x + b.x, this.y + b.y);
		return this
	},
	add: function(b, d) {
		this.set(b.x + d.x, b.y + d.y);
		return this
	},
	subSelf: function(b) {
		this.set(this.x - b.x, this.y - b.y);
		return this
	},
	sub: function(b, d) {
		this.set(b.x - d.x, b.y - d.y);
		return this
	},
	multiplyScalar: function(b) {
		this.set(this.x * b, this.y * b);
		return this
	},
	negate: function() {
		this.set(-this.x, -this.y);
		return this
	},
	unit: function() {
		this.multiplyScalar(1 /
			this.length());
		return this
	},
	length: function() {
		return Math.sqrt(this.lengthSq())
	},
	lengthSq: function() {
		return this.x * this.x + this.y * this.y
	},
	clone: function() {
		return new THREE.Vector2(this.x, this.y)
	}
};
THREE.Vector3 = function(b, d, e) {
	this.set(b || 0, d || 0, e || 0)
};
THREE.Vector3.prototype = {
	set: function(b, d, e) {
		this.x = b;
		this.y = d;
		this.z = e;
		return this
	},
	copy: function(b) {
		this.set(b.x, b.y, b.z);
		return this
	},
	add: function(b, d) {
		this.set(b.x + d.x, b.y + d.y, b.z + d.z);
		return this
	},
	addSelf: function(b) {
		this.set(this.x + b.x, this.y + b.y, this.z + b.z);
		return this
	},
	addScalar: function(b) {
		this.set(this.x + b, this.y + b, this.z + b);
		return this
	},
	sub: function(b, d) {
		this.set(b.x - d.x, b.y - d.y, b.z - d.z);
		return this
	},
	subSelf: function(b) {
		this.set(this.x - b.x, this.y - b.y, this.z - b.z);
		return this
	},
	cross: function(b,
		d) {
		this.set(b.y * d.z - b.z * d.y, b.z * d.x - b.x * d.z, b.x * d.y - b.y * d.x);
		return this
	},
	crossSelf: function(b) {
		var d = this.x,
			e = this.y,
			g = this.z;
		this.set(e * b.z - g * b.y, g * b.x - d * b.z, d * b.y - e * b.x);
		return this
	},
	multiply: function(b, d) {
		this.set(b.x * d.x, b.y * d.y, b.z * d.z);
		return this
	},
	multiplySelf: function(b) {
		this.set(this.x * b.x, this.y * b.y, this.z * b.z);
		return this
	},
	multiplyScalar: function(b) {
		this.set(this.x * b, this.y * b, this.z * b);
		return this
	},
	divideSelf: function(b) {
		this.set(this.x / b.x, this.y / b.y, this.z / b.z);
		return this
	},
	divideScalar: function(b) {
		this.set(this.x /
			b, this.y / b, this.z / b);
		return this
	},
	negate: function() {
		this.set(-this.x, -this.y, -this.z);
		return this
	},
	dot: function(b) {
		return this.x * b.x + this.y * b.y + this.z * b.z
	},
	distanceTo: function(b) {
		return Math.sqrt(this.distanceToSquared(b))
	},
	distanceToSquared: function(b) {
		var d = this.x - b.x,
			e = this.y - b.y;
		b = this.z - b.z;
		return d * d + e * e + b * b
	},
	length: function() {
		return Math.sqrt(this.lengthSq())
	},
	lengthSq: function() {
		return this.x * this.x + this.y * this.y + this.z * this.z
	},
	lengthManhattan: function() {
		return this.x + this.y + this.z
	},
	normalize: function() {
		var b =
			this.length();
		b > 0 ? this.multiplyScalar(1 / b) : this.set(0, 0, 0);
		return this
	},
	setPositionFromMatrix: function(b) {
		this.x = b.n14;
		this.y = b.n24;
		this.z = b.n34
	},
	setRotationFromMatrix: function(b) {
		this.y = Math.asin(b.n13);
		var d = Math.cos(this.y);
		if(Math.abs(d) > 1.0E-5) {
			this.x = Math.atan2(-b.n23 / d, b.n33 / d);
			this.z = Math.atan2(-b.n13 / d, b.n11 / d)
		} else {
			this.x = 0;
			this.z = Math.atan2(b.n21, b.n22)
		}
	},
	setLength: function(b) {
		return this.normalize().multiplyScalar(b)
	},
	isZero: function() {
		return Math.abs(this.x) < 1.0E-4 && Math.abs(this.y) <
			1.0E-4 && Math.abs(this.z) < 1.0E-4
	},
	clone: function() {
		return new THREE.Vector3(this.x, this.y, this.z)
	}
};
THREE.Vector4 = function(b, d, e, g) {
	this.set(b || 0, d || 0, e || 0, g || 1)
};
THREE.Vector4.prototype = {
	set: function(b, d, e, g) {
		this.x = b;
		this.y = d;
		this.z = e;
		this.w = g;
		return this
	},
	copy: function(b) {
		this.set(b.x, b.y, b.z, b.w || 1);
		return this
	},
	add: function(b, d) {
		this.set(b.x + d.x, b.y + d.y, b.z + d.z, b.w + d.w);
		return this
	},
	addSelf: function(b) {
		this.set(this.x + b.x, this.y + b.y, this.z + b.z, this.w + b.w);
		return this
	},
	sub: function(b, d) {
		this.set(b.x - d.x, b.y - d.y, b.z - d.z, b.w - d.w);
		return this
	},
	subSelf: function(b) {
		this.set(this.x - b.x, this.y - b.y, this.z - b.z, this.w - b.w);
		return this
	},
	multiplyScalar: function(b) {
		this.set(this.x *
			b, this.y * b, this.z * b, this.w * b);
		return this
	},
	divideScalar: function(b) {
		this.set(this.x / b, this.y / b, this.z / b, this.w / b);
		return this
	},
	lerpSelf: function(b, d) {
		this.set(this.x + (b.x - this.x) * d, this.y + (b.y - this.y) * d, this.z + (b.z - this.z) * d, this.w + (b.w - this.w) * d)
	},
	clone: function() {
		return new THREE.Vector4(this.x, this.y, this.z, this.w)
	}
};
THREE.Ray = function(b, d) {
	this.origin = b || new THREE.Vector3;
	this.direction = d || new THREE.Vector3
};
THREE.Ray.prototype = {
	intersectScene: function(b) {
		var d, e, g = b.objects,
			h = [];
		b = 0;
		for(d = g.length; b < d; b++) {
			e = g[b];
			e instanceof THREE.Mesh && (h = h.concat(this.intersectObject(e)))
		}
		h.sort(function(o, n) {
			return o.distance - n.distance
		});
		return h
	},
	intersectObject: function(b) {
		function d(V, L, sa, da) {
			da = da.clone().subSelf(L);
			sa = sa.clone().subSelf(L);
			var oa = V.clone().subSelf(L);
			V = da.dot(da);
			L = da.dot(sa);
			da = da.dot(oa);
			var Z = sa.dot(sa);
			sa = sa.dot(oa);
			oa = 1 / (V * Z - L * L);
			Z = (Z * da - L * sa) * oa;
			V = (V * sa - L * da) * oa;
			return Z > 0 && V > 0 && Z + V <
				1
		}
		var e, g, h, o, n, p, q, v, E, F, H, I = b.geometry,
			M = I.vertices,
			N = [];
		e = 0;
		for(g = I.faces.length; e < g; e++) {
			h = I.faces[e];
			F = this.origin.clone();
			H = this.direction.clone();
			q = b.matrixWorld;
			o = q.multiplyVector3(M[h.a].position.clone());
			n = q.multiplyVector3(M[h.b].position.clone());
			p = q.multiplyVector3(M[h.c].position.clone());
			q = h instanceof THREE.Face4 ? q.multiplyVector3(M[h.d].position.clone()) : null;
			v = b.matrixRotationWorld.multiplyVector3(h.normal.clone());
			E = H.dot(v);
			if(b.doubleSided || (b.flipSided ? E > 0 : E < 0)) {
				v = v.dot((new THREE.Vector3).sub(o,
					F)) / E;
				F = F.addSelf(H.multiplyScalar(v));
				if(h instanceof THREE.Face3) {
					if(d(F, o, n, p)) {
						h = {
							distance: this.origin.distanceTo(F),
							point: F,
							face: h,
							object: b
						};
						N.push(h)
					}
				} else if(h instanceof THREE.Face4 && (d(F, o, n, q) || d(F, n, p, q))) {
					h = {
						distance: this.origin.distanceTo(F),
						point: F,
						face: h,
						object: b
					};
					N.push(h)
				}
			}
		}
		return N
	}
};
THREE.Rectangle = function() {
	function b() {
		o = g - d;
		n = h - e
	}
	var d, e, g, h, o, n, p = !0;
	this.getX = function() {
		return d
	};
	this.getY = function() {
		return e
	};
	this.getWidth = function() {
		return o
	};
	this.getHeight = function() {
		return n
	};
	this.getLeft = function() {
		return d
	};
	this.getTop = function() {
		return e
	};
	this.getRight = function() {
		return g
	};
	this.getBottom = function() {
		return h
	};
	this.set = function(q, v, E, F) {
		p = !1;
		d = q;
		e = v;
		g = E;
		h = F;
		b()
	};
	this.addPoint = function(q, v) {
		if(p) {
			p = !1;
			d = q;
			e = v;
			g = q;
			h = v
		} else {
			d = d < q ? d : q;
			e = e < v ? e : v;
			g = g > q ? g : q;
			h = h > v ? h : v
		}
		b()
	};
	this.add3Points = function(q, v, E, F, H, I) {
		if(p) {
			p = !1;
			d = q < E ? q < H ? q : H : E < H ? E : H;
			e = v < F ? v < I ? v : I : F < I ? F : I;
			g = q > E ? q > H ? q : H : E > H ? E : H;
			h = v > F ? v > I ? v : I : F > I ? F : I
		} else {
			d = q < E ? q < H ? q < d ? q : d : H < d ? H : d : E < H ? E < d ? E : d : H < d ? H : d;
			e = v < F ? v < I ? v < e ? v : e : I < e ? I : e : F < I ? F < e ? F : e : I < e ? I : e;
			g = q > E ? q > H ? q > g ? q : g : H > g ? H : g : E > H ? E > g ? E : g : H > g ? H : g;
			h = v > F ? v > I ? v > h ? v : h : I > h ? I : h : F > I ? F > h ? F : h : I > h ? I : h
		}
		b()
	};
	this.addRectangle = function(q) {
		if(p) {
			p = !1;
			d = q.getLeft();
			e = q.getTop();
			g = q.getRight();
			h = q.getBottom()
		} else {
			d = d < q.getLeft() ? d : q.getLeft();
			e = e < q.getTop() ? e : q.getTop();
			g = g > q.getRight() ?
				g : q.getRight();
			h = h > q.getBottom() ? h : q.getBottom()
		}
		b()
	};
	this.inflate = function(q) {
		d -= q;
		e -= q;
		g += q;
		h += q;
		b()
	};
	this.minSelf = function(q) {
		d = d > q.getLeft() ? d : q.getLeft();
		e = e > q.getTop() ? e : q.getTop();
		g = g < q.getRight() ? g : q.getRight();
		h = h < q.getBottom() ? h : q.getBottom();
		b()
	};
	this.instersects = function(q) {
		return Math.min(g, q.getRight()) - Math.max(d, q.getLeft()) >= 0 && Math.min(h, q.getBottom()) - Math.max(e, q.getTop()) >= 0
	};
	this.empty = function() {
		p = !0;
		h = g = e = d = 0;
		b()
	};
	this.isEmpty = function() {
		return p
	}
};
THREE.Matrix3 = function() {
	this.m = []
};
THREE.Matrix3.prototype = {
	transpose: function() {
		var b, d = this.m;
		b = d[1];
		d[1] = d[3];
		d[3] = b;
		b = d[2];
		d[2] = d[6];
		d[6] = b;
		b = d[5];
		d[5] = d[7];
		d[7] = b;
		return this
	},
	transposeIntoArray: function(b) {
		var d = this.m;
		b[0] = d[0];
		b[1] = d[3];
		b[2] = d[6];
		b[3] = d[1];
		b[4] = d[4];
		b[5] = d[7];
		b[6] = d[2];
		b[7] = d[5];
		b[8] = d[8];
		return this
	}
};
THREE.Matrix4 = function(b, d, e, g, h, o, n, p, q, v, E, F, H, I, M, N) {
	this.set(b || 1, d || 0, e || 0, g || 0, h || 0, o || 1, n || 0, p || 0, q || 0, v || 0, E || 1, F || 0, H || 0, I || 0, M || 0, N || 1);
	this.flat = Array(16);
	this.m33 = new THREE.Matrix3
};
THREE.Matrix4.prototype = {
	set: function(b, d, e, g, h, o, n, p, q, v, E, F, H, I, M, N) {
		this.n11 = b;
		this.n12 = d;
		this.n13 = e;
		this.n14 = g;
		this.n21 = h;
		this.n22 = o;
		this.n23 = n;
		this.n24 = p;
		this.n31 = q;
		this.n32 = v;
		this.n33 = E;
		this.n34 = F;
		this.n41 = H;
		this.n42 = I;
		this.n43 = M;
		this.n44 = N;
		return this
	},
	identity: function() {
		this.set(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1);
		return this
	},
	copy: function(b) {
		this.set(b.n11, b.n12, b.n13, b.n14, b.n21, b.n22, b.n23, b.n24, b.n31, b.n32, b.n33, b.n34, b.n41, b.n42, b.n43, b.n44);
		return this
	},
	lookAt: function(b, d, e) {
		var g = THREE.Matrix4.__v1,
			h = THREE.Matrix4.__v2,
			o = THREE.Matrix4.__v3;
		o.sub(b, d).normalize();
		if(o.length() === 0) o.z = 1;
		g.cross(e, o).normalize();
		if(g.length() === 0) {
			o.x += 1.0E-4;
			g.cross(e, o).normalize()
		}
		h.cross(o, g).normalize();
		this.n11 = g.x;
		this.n12 = h.x;
		this.n13 = o.x;
		this.n21 = g.y;
		this.n22 = h.y;
		this.n23 = o.y;
		this.n31 = g.z;
		this.n32 = h.z;
		this.n33 = o.z;
		return this
	},
	multiplyVector3: function(b) {
		var d = b.x,
			e = b.y,
			g = b.z,
			h = 1 / (this.n41 * d + this.n42 * e + this.n43 * g + this.n44);
		b.x = (this.n11 * d + this.n12 * e + this.n13 * g + this.n14) * h;
		b.y = (this.n21 * d + this.n22 * e + this.n23 *
			g + this.n24) * h;
		b.z = (this.n31 * d + this.n32 * e + this.n33 * g + this.n34) * h;
		return b
	},
	multiplyVector4: function(b) {
		var d = b.x,
			e = b.y,
			g = b.z,
			h = b.w;
		b.x = this.n11 * d + this.n12 * e + this.n13 * g + this.n14 * h;
		b.y = this.n21 * d + this.n22 * e + this.n23 * g + this.n24 * h;
		b.z = this.n31 * d + this.n32 * e + this.n33 * g + this.n34 * h;
		b.w = this.n41 * d + this.n42 * e + this.n43 * g + this.n44 * h;
		return b
	},
	rotateAxis: function(b) {
		var d = b.x,
			e = b.y,
			g = b.z;
		b.x = d * this.n11 + e * this.n12 + g * this.n13;
		b.y = d * this.n21 + e * this.n22 + g * this.n23;
		b.z = d * this.n31 + e * this.n32 + g * this.n33;
		b.normalize();
		return b
	},
	crossVector: function(b) {
		var d = new THREE.Vector4;
		d.x = this.n11 * b.x + this.n12 * b.y + this.n13 * b.z + this.n14 * b.w;
		d.y = this.n21 * b.x + this.n22 * b.y + this.n23 * b.z + this.n24 * b.w;
		d.z = this.n31 * b.x + this.n32 * b.y + this.n33 * b.z + this.n34 * b.w;
		d.w = b.w ? this.n41 * b.x + this.n42 * b.y + this.n43 * b.z + this.n44 * b.w : 1;
		return d
	},
	multiply: function(b, d) {
		var e = b.n11,
			g = b.n12,
			h = b.n13,
			o = b.n14,
			n = b.n21,
			p = b.n22,
			q = b.n23,
			v = b.n24,
			E = b.n31,
			F = b.n32,
			H = b.n33,
			I = b.n34,
			M = b.n41,
			N = b.n42,
			V = b.n43,
			L = b.n44,
			sa = d.n11,
			da = d.n12,
			oa = d.n13,
			Z = d.n14,
			K = d.n21,
			Ia = d.n22,
			ca = d.n23,
			Ea = d.n24,
			fa = d.n31,
			c = d.n32,
			S = d.n33,
			pa = d.n34;
		this.n11 = e * sa + g * K + h * fa;
		this.n12 = e * da + g * Ia + h * c;
		this.n13 = e * oa + g * ca + h * S;
		this.n14 = e * Z + g * Ea + h * pa + o;
		this.n21 = n * sa + p * K + q * fa;
		this.n22 = n * da + p * Ia + q * c;
		this.n23 = n * oa + p * ca + q * S;
		this.n24 = n * Z + p * Ea + q * pa + v;
		this.n31 = E * sa + F * K + H * fa;
		this.n32 = E * da + F * Ia + H * c;
		this.n33 = E * oa + F * ca + H * S;
		this.n34 = E * Z + F * Ea + H * pa + I;
		this.n41 = M * sa + N * K + V * fa;
		this.n42 = M * da + N * Ia + V * c;
		this.n43 = M * oa + N * ca + V * S;
		this.n44 = M * Z + N * Ea + V * pa + L;
		return this
	},
	multiplyToArray: function(b, d, e) {
		this.multiply(b, d);
		e[0] = this.n11;
		e[1] = this.n21;
		e[2] = this.n31;
		e[3] = this.n41;
		e[4] = this.n12;
		e[5] = this.n22;
		e[6] = this.n32;
		e[7] = this.n42;
		e[8] = this.n13;
		e[9] = this.n23;
		e[10] = this.n33;
		e[11] = this.n43;
		e[12] = this.n14;
		e[13] = this.n24;
		e[14] = this.n34;
		e[15] = this.n44;
		return this
	},
	multiplySelf: function(b) {
		this.multiply(this, b);
		return this
	},
	multiplyScalar: function(b) {
		this.n11 *= b;
		this.n12 *= b;
		this.n13 *= b;
		this.n14 *= b;
		this.n21 *= b;
		this.n22 *= b;
		this.n23 *= b;
		this.n24 *= b;
		this.n31 *= b;
		this.n32 *= b;
		this.n33 *= b;
		this.n34 *= b;
		this.n41 *= b;
		this.n42 *= b;
		this.n43 *= b;
		this.n44 *=
			b;
		return this
	},
	determinant: function() {
		var b = this.n11,
			d = this.n12,
			e = this.n13,
			g = this.n14,
			h = this.n21,
			o = this.n22,
			n = this.n23,
			p = this.n24,
			q = this.n31,
			v = this.n32,
			E = this.n33,
			F = this.n34,
			H = this.n41,
			I = this.n42,
			M = this.n43,
			N = this.n44;
		return g * n * v * H - e * p * v * H - g * o * E * H + d * p * E * H + e * o * F * H - d * n * F * H - g * n * q * I + e * p * q * I + g * h * E * I - b * p * E * I - e * h * F * I + b * n * F * I + g * o * q * M - d * p * q * M - g * h * v * M + b * p * v * M + d * h * F * M - b * o * F * M - e * o * q * N + d * n * q * N + e * h * v * N - b * n * v * N - d * h * E * N + b * o * E * N
	},
	transpose: function() {
		var b;
		b = this.n21;
		this.n21 = this.n12;
		this.n12 = b;
		b = this.n31;
		this.n31 =
			this.n13;
		this.n13 = b;
		b = this.n32;
		this.n32 = this.n23;
		this.n23 = b;
		b = this.n41;
		this.n41 = this.n14;
		this.n14 = b;
		b = this.n42;
		this.n42 = this.n24;
		this.n24 = b;
		b = this.n43;
		this.n43 = this.n34;
		this.n43 = b;
		return this
	},
	clone: function() {
		var b = new THREE.Matrix4;
		b.n11 = this.n11;
		b.n12 = this.n12;
		b.n13 = this.n13;
		b.n14 = this.n14;
		b.n21 = this.n21;
		b.n22 = this.n22;
		b.n23 = this.n23;
		b.n24 = this.n24;
		b.n31 = this.n31;
		b.n32 = this.n32;
		b.n33 = this.n33;
		b.n34 = this.n34;
		b.n41 = this.n41;
		b.n42 = this.n42;
		b.n43 = this.n43;
		b.n44 = this.n44;
		return b
	},
	flatten: function() {
		this.flat[0] =
			this.n11;
		this.flat[1] = this.n21;
		this.flat[2] = this.n31;
		this.flat[3] = this.n41;
		this.flat[4] = this.n12;
		this.flat[5] = this.n22;
		this.flat[6] = this.n32;
		this.flat[7] = this.n42;
		this.flat[8] = this.n13;
		this.flat[9] = this.n23;
		this.flat[10] = this.n33;
		this.flat[11] = this.n43;
		this.flat[12] = this.n14;
		this.flat[13] = this.n24;
		this.flat[14] = this.n34;
		this.flat[15] = this.n44;
		return this.flat
	},
	flattenToArray: function(b) {
		b[0] = this.n11;
		b[1] = this.n21;
		b[2] = this.n31;
		b[3] = this.n41;
		b[4] = this.n12;
		b[5] = this.n22;
		b[6] = this.n32;
		b[7] = this.n42;
		b[8] = this.n13;
		b[9] = this.n23;
		b[10] = this.n33;
		b[11] = this.n43;
		b[12] = this.n14;
		b[13] = this.n24;
		b[14] = this.n34;
		b[15] = this.n44;
		return b
	},
	flattenToArrayOffset: function(b, d) {
		b[d] = this.n11;
		b[d + 1] = this.n21;
		b[d + 2] = this.n31;
		b[d + 3] = this.n41;
		b[d + 4] = this.n12;
		b[d + 5] = this.n22;
		b[d + 6] = this.n32;
		b[d + 7] = this.n42;
		b[d + 8] = this.n13;
		b[d + 9] = this.n23;
		b[d + 10] = this.n33;
		b[d + 11] = this.n43;
		b[d + 12] = this.n14;
		b[d + 13] = this.n24;
		b[d + 14] = this.n34;
		b[d + 15] = this.n44;
		return b
	},
	setTranslation: function(b, d, e) {
		this.set(1, 0, 0, b, 0, 1, 0, d, 0, 0, 1, e, 0, 0,
			0, 1);
		return this
	},
	setScale: function(b, d, e) {
		this.set(b, 0, 0, 0, 0, d, 0, 0, 0, 0, e, 0, 0, 0, 0, 1);
		return this
	},
	setRotationX: function(b) {
		var d = Math.cos(b);
		b = Math.sin(b);
		this.set(1, 0, 0, 0, 0, d, -b, 0, 0, b, d, 0, 0, 0, 0, 1);
		return this
	},
	setRotationY: function(b) {
		var d = Math.cos(b);
		b = Math.sin(b);
		this.set(d, 0, b, 0, 0, 1, 0, 0, -b, 0, d, 0, 0, 0, 0, 1);
		return this
	},
	setRotationZ: function(b) {
		var d = Math.cos(b);
		b = Math.sin(b);
		this.set(d, -b, 0, 0, b, d, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1);
		return this
	},
	setRotationAxis: function(b, d) {
		var e = Math.cos(d),
			g = Math.sin(d),
			h =
			1 - e,
			o = b.x,
			n = b.y,
			p = b.z,
			q = h * o,
			v = h * n;
		this.set(q * o + e, q * n - g * p, q * p + g * n, 0, q * n + g * p, v * n + e, v * p - g * o, 0, q * p - g * n, v * p + g * o, h * p * p + e, 0, 0, 0, 0, 1);
		return this
	},
	setPosition: function(b) {
		this.n14 = b.x;
		this.n24 = b.y;
		this.n34 = b.z;
		return this
	},
	setRotationFromEuler: function(b) {
		var d = b.x,
			e = b.y,
			g = b.z;
		b = Math.cos(d);
		d = Math.sin(d);
		var h = Math.cos(e);
		e = Math.sin(e);
		var o = Math.cos(g);
		g = Math.sin(g);
		var n = b * e,
			p = d * e;
		this.n11 = h * o;
		this.n12 = -h * g;
		this.n13 = e;
		this.n21 = p * o + b * g;
		this.n22 = -p * g + b * o;
		this.n23 = -d * h;
		this.n31 = -n * o + d * g;
		this.n32 = n * g + d * o;
		this.n33 =
			b * h;
		return this
	},
	setRotationFromQuaternion: function(b) {
		var d = b.x,
			e = b.y,
			g = b.z,
			h = b.w,
			o = d + d,
			n = e + e,
			p = g + g;
		b = d * o;
		var q = d * n;
		d *= p;
		var v = e * n;
		e *= p;
		g *= p;
		o *= h;
		n *= h;
		h *= p;
		this.n11 = 1 - (v + g);
		this.n12 = q - h;
		this.n13 = d + n;
		this.n21 = q + h;
		this.n22 = 1 - (b + g);
		this.n23 = e - o;
		this.n31 = d - n;
		this.n32 = e + o;
		this.n33 = 1 - (b + v);
		return this
	},
	scale: function(b) {
		var d = b.x,
			e = b.y;
		b = b.z;
		this.n11 *= d;
		this.n12 *= e;
		this.n13 *= b;
		this.n21 *= d;
		this.n22 *= e;
		this.n23 *= b;
		this.n31 *= d;
		this.n32 *= e;
		this.n33 *= b;
		this.n41 *= d;
		this.n42 *= e;
		this.n43 *= b;
		return this
	},
	extractPosition: function(b) {
		this.n14 =
			b.n14;
		this.n24 = b.n24;
		this.n34 = b.n34
	},
	extractRotation: function(b, d) {
		var e = 1 / d.x,
			g = 1 / d.y,
			h = 1 / d.z;
		this.n11 = b.n11 * e;
		this.n21 = b.n21 * e;
		this.n31 = b.n31 * e;
		this.n12 = b.n12 * g;
		this.n22 = b.n22 * g;
		this.n32 = b.n32 * g;
		this.n13 = b.n13 * h;
		this.n23 = b.n23 * h;
		this.n33 = b.n33 * h
	}
};
THREE.Matrix4.makeInvert = function(b, d) {
	var e = b.n11,
		g = b.n12,
		h = b.n13,
		o = b.n14,
		n = b.n21,
		p = b.n22,
		q = b.n23,
		v = b.n24,
		E = b.n31,
		F = b.n32,
		H = b.n33,
		I = b.n34,
		M = b.n41,
		N = b.n42,
		V = b.n43,
		L = b.n44;
	d === undefined && (d = new THREE.Matrix4);
	d.n11 = q * I * N - v * H * N + v * F * V - p * I * V - q * F * L + p * H * L;
	d.n12 = o * H * N - h * I * N - o * F * V + g * I * V + h * F * L - g * H * L;
	d.n13 = h * v * N - o * q * N + o * p * V - g * v * V - h * p * L + g * q * L;
	d.n14 = o * q * F - h * v * F - o * p * H + g * v * H + h * p * I - g * q * I;
	d.n21 = v * H * M - q * I * M - v * E * V + n * I * V + q * E * L - n * H * L;
	d.n22 = h * I * M - o * H * M + o * E * V - e * I * V - h * E * L + e * H * L;
	d.n23 = o * q * M - h * v * M - o * n * V + e * v * V + h * n * L - e * q * L;
	d.n24 = h * v * E - o * q * E + o * n * H - e * v * H - h * n * I + e * q * I;
	d.n31 = p * I * M - v * F * M + v * E * N - n * I * N - p * E * L + n * F * L;
	d.n32 = o * F * M - g * I * M - o * E * N + e * I * N + g * E * L - e * F * L;
	d.n33 = h * v * M - o * p * M + o * n * N - e * v * N - g * n * L + e * p * L;
	d.n34 = o * p * E - g * v * E - o * n * F + e * v * F + g * n * I - e * p * I;
	d.n41 = q * F * M - p * H * M - q * E * N + n * H * N + p * E * V - n * F * V;
	d.n42 = g * H * M - h * F * M + h * E * N - e * H * N - g * E * V + e * F * V;
	d.n43 = h * p * M - g * q * M - h * n * N + e * q * N + g * n * V - e * p * V;
	d.n44 = g * q * E - h * p * E + h * n * F - e * q * F - g * n * H + e * p * H;
	d.multiplyScalar(1 / b.determinant());
	return d
};
THREE.Matrix4.makeInvert3x3 = function(b) {
	var d = b.m33,
		e = d.m,
		g = b.n33 * b.n22 - b.n32 * b.n23,
		h = -b.n33 * b.n21 + b.n31 * b.n23,
		o = b.n32 * b.n21 - b.n31 * b.n22,
		n = -b.n33 * b.n12 + b.n32 * b.n13,
		p = b.n33 * b.n11 - b.n31 * b.n13,
		q = -b.n32 * b.n11 + b.n31 * b.n12,
		v = b.n23 * b.n12 - b.n22 * b.n13,
		E = -b.n23 * b.n11 + b.n21 * b.n13,
		F = b.n22 * b.n11 - b.n21 * b.n12;
	b = b.n11 * g + b.n21 * n + b.n31 * v;
	if(b == 0) throw "matrix not invertible";
	b = 1 / b;
	e[0] = b * g;
	e[1] = b * h;
	e[2] = b * o;
	e[3] = b * n;
	e[4] = b * p;
	e[5] = b * q;
	e[6] = b * v;
	e[7] = b * E;
	e[8] = b * F;
	return d
};
THREE.Matrix4.makeFrustum = function(b, d, e, g, h, o) {
	var n;
	n = new THREE.Matrix4;
	n.n11 = 2 * h / (d - b);
	n.n12 = 0;
	n.n13 = (d + b) / (d - b);
	n.n14 = 0;
	n.n21 = 0;
	n.n22 = 2 * h / (g - e);
	n.n23 = (g + e) / (g - e);
	n.n24 = 0;
	n.n31 = 0;
	n.n32 = 0;
	n.n33 = -(o + h) / (o - h);
	n.n34 = -2 * o * h / (o - h);
	n.n41 = 0;
	n.n42 = 0;
	n.n43 = -1;
	n.n44 = 0;
	return n
};
THREE.Matrix4.makePerspective = function(b, d, e, g) {
	var h;
	b = e * Math.tan(b * Math.PI / 360);
	h = -b;
	return THREE.Matrix4.makeFrustum(h * d, b * d, h, b, e, g)
};
THREE.Matrix4.makeOrtho = function(b, d, e, g, h, o) {
	var n, p, q, v;
	n = new THREE.Matrix4;
	p = d - b;
	q = e - g;
	v = o - h;
	n.n11 = 2 / p;
	n.n12 = 0;
	n.n13 = 0;
	n.n14 = -((d + b) / p);
	n.n21 = 0;
	n.n22 = 2 / q;
	n.n23 = 0;
	n.n24 = -((e + g) / q);
	n.n31 = 0;
	n.n32 = 0;
	n.n33 = -2 / v;
	n.n34 = -((o + h) / v);
	n.n41 = 0;
	n.n42 = 0;
	n.n43 = 0;
	n.n44 = 1;
	return n
};
THREE.Matrix4.__v1 = new THREE.Vector3;
THREE.Matrix4.__v2 = new THREE.Vector3;
THREE.Matrix4.__v3 = new THREE.Vector3;
THREE.Object3D = function() {
	this.parent = undefined;
	this.children = [];
	this.up = new THREE.Vector3(0, 1, 0);
	this.position = new THREE.Vector3;
	this.rotation = new THREE.Vector3;
	this.scale = new THREE.Vector3(1, 1, 1);
	this.rotationAutoUpdate = !0;
	this.matrix = new THREE.Matrix4;
	this.matrixWorld = new THREE.Matrix4;
	this.matrixRotationWorld = new THREE.Matrix4;
	this.matrixAutoUpdate = !0;
	this.matrixWorldNeedsUpdate = !0;
	this.quaternion = new THREE.Quaternion;
	this.useQuaternion = !1;
	this.boundRadius = 0;
	this.boundRadiusScale = 1;
	this.visible = !0;
	this._vector = new THREE.Vector3
};
THREE.Object3D.prototype = {
	translate: function(b, d) {
		this.matrix.rotateAxis(d);
		this.position.addSelf(d.multiplyScalar(b))
	},
	translateX: function(b) {
		this.translate(b, this._vector.set(1, 0, 0))
	},
	translateY: function(b) {
		this.translate(b, this._vector.set(0, 1, 0))
	},
	translateZ: function(b) {
		this.translate(b, this._vector.set(0, 0, 1))
	},
	lookAt: function(b) {
		this.matrix.lookAt(this.position, b, this.up);
		this.rotationAutoUpdate && this.rotation.setRotationFromMatrix(this.matrix)
	},
	addChild: function(b) {
		if(this.children.indexOf(b) === -1) {
			b.parent !==
				undefined && b.parent.removeChild(b);
			b.parent = this;
			this.children.push(b);
			for(var d = this; d instanceof THREE.Scene === !1 && d !== undefined;) d = d.parent;
			d !== undefined && d.addChildRecurse(b)
		}
	},
	removeChild: function(b) {
		var d = this.children.indexOf(b);
		if(d !== -1) {
			b.parent = undefined;
			this.children.splice(d, 1)
		}
	},
	updateMatrix: function() {
		this.matrix.setPosition(this.position);
		this.useQuaternion ? this.matrix.setRotationFromQuaternion(this.quaternion) : this.matrix.setRotationFromEuler(this.rotation);
		if(this.scale.x !== 1 || this.scale.y !==
			1 || this.scale.z !== 1) {
			this.matrix.scale(this.scale);
			this.boundRadiusScale = Math.max(this.scale.x, Math.max(this.scale.y, this.scale.z))
		}
		this.matrixWorldNeedsUpdate = !0
	},
	update: function(b, d, e) {
		this.matrixAutoUpdate && this.updateMatrix();
		if(this.matrixWorldNeedsUpdate || d) {
			b ? this.matrixWorld.multiply(b, this.matrix) : this.matrixWorld.copy(this.matrix);
			this.matrixRotationWorld.extractRotation(this.matrixWorld, this.scale);
			this.matrixWorldNeedsUpdate = !1;
			d = !0
		}
		b = 0;
		for(var g = this.children.length; b < g; b++) this.children[b].update(this.matrixWorld,
			d, e)
	}
};
THREE.Quaternion = function(b, d, e, g) {
	this.set(b || 0, d || 0, e || 0, g !== undefined ? g : 1)
};
THREE.Quaternion.prototype = {
	set: function(b, d, e, g) {
		this.x = b;
		this.y = d;
		this.z = e;
		this.w = g;
		return this
	},
	setFromEuler: function(b) {
		var d = 0.5 * Math.PI / 360,
			e = b.x * d,
			g = b.y * d,
			h = b.z * d;
		b = Math.cos(g);
		g = Math.sin(g);
		d = Math.cos(-h);
		h = Math.sin(-h);
		var o = Math.cos(e);
		e = Math.sin(e);
		var n = b * d,
			p = g * h;
		this.w = n * o - p * e;
		this.x = n * e + p * o;
		this.y = g * d * o + b * h * e;
		this.z = b * h * o - g * d * e;
		return this
	},
	calculateW: function() {
		this.w = -Math.sqrt(Math.abs(1 - this.x * this.x - this.y * this.y - this.z * this.z));
		return this
	},
	inverse: function() {
		this.x *= -1;
		this.y *=
			-1;
		this.z *= -1;
		return this
	},
	length: function() {
		return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w)
	},
	normalize: function() {
		var b = Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w);
		if(b == 0) this.w = this.z = this.y = this.x = 0;
		else {
			b = 1 / b;
			this.x *= b;
			this.y *= b;
			this.z *= b;
			this.w *= b
		}
		return this
	},
	multiplySelf: function(b) {
		var d = this.x,
			e = this.y,
			g = this.z,
			h = this.w,
			o = b.x,
			n = b.y,
			p = b.z;
		b = b.w;
		this.x = d * b + h * o + e * p - g * n;
		this.y = e * b + h * n + g * o - d * p;
		this.z = g * b + h * p + d * n - e * o;
		this.w = h * b - d * o - e * n - g * p;
		return this
	},
	multiplyVector3: function(b, d) {
		d || (d = b);
		var e = b.x,
			g = b.y,
			h = b.z,
			o = this.x,
			n = this.y,
			p = this.z,
			q = this.w,
			v = q * e + n * h - p * g,
			E = q * g + p * e - o * h,
			F = q * h + o * g - n * e;
		e = -o * e - n * g - p * h;
		d.x = v * q + e * -o + E * -p - F * -n;
		d.y = E * q + e * -n + F * -o - v * -p;
		d.z = F * q + e * -p + v * -n - E * -o;
		return d
	}
};
THREE.Quaternion.slerp = function(b, d, e, g) {
	var h = b.w * d.w + b.x * d.x + b.y * d.y + b.z * d.z;
	if(Math.abs(h) >= 1) {
		e.w = b.w;
		e.x = b.x;
		e.y = b.y;
		e.z = b.z;
		return e
	}
	var o = Math.acos(h),
		n = Math.sqrt(1 - h * h);
	if(Math.abs(n) < 0.0010) {
		e.w = 0.5 * (b.w + d.w);
		e.x = 0.5 * (b.x + d.x);
		e.y = 0.5 * (b.y + d.y);
		e.z = 0.5 * (b.z + d.z);
		return e
	}
	h = Math.sin((1 - g) * o) / n;
	g = Math.sin(g * o) / n;
	e.w = b.w * h + d.w * g;
	e.x = b.x * h + d.x * g;
	e.y = b.y * h + d.y * g;
	e.z = b.z * h + d.z * g;
	return e
};
THREE.Vertex = function(b) {
	this.position = b || new THREE.Vector3
};
THREE.Face3 = function(b, d, e, g, h, o) {
	this.a = b;
	this.b = d;
	this.c = e;
	this.normal = g instanceof THREE.Vector3 ? g : new THREE.Vector3;
	this.vertexNormals = g instanceof Array ? g : [];
	this.color = h instanceof THREE.Color ? h : new THREE.Color;
	this.vertexColors = h instanceof Array ? h : [];
	this.vertexTangents = [];
	this.materials = o instanceof Array ? o : [o];
	this.centroid = new THREE.Vector3
};
THREE.Face4 = function(b, d, e, g, h, o, n) {
	this.a = b;
	this.b = d;
	this.c = e;
	this.d = g;
	this.normal = h instanceof THREE.Vector3 ? h : new THREE.Vector3;
	this.vertexNormals = h instanceof Array ? h : [];
	this.color = o instanceof THREE.Color ? o : new THREE.Color;
	this.vertexColors = o instanceof Array ? o : [];
	this.vertexTangents = [];
	this.materials = n instanceof Array ? n : [n];
	this.centroid = new THREE.Vector3
};
THREE.UV = function(b, d) {
	this.set(b || 0, d || 0)
};
THREE.UV.prototype = {
	set: function(b, d) {
		this.u = b;
		this.v = d;
		return this
	},
	copy: function(b) {
		this.set(b.u, b.v);
		return this
	}
};
THREE.Geometry = function() {
	this.id = "Geometry" + THREE.GeometryIdCounter++;
	this.vertices = [];
	this.colors = [];
	this.faces = [];
	this.edges = [];
	this.faceUvs = [
		[]
	];
	this.faceVertexUvs = [
		[]
	];
	this.morphTargets = [];
	this.morphColors = [];
	this.skinWeights = [];
	this.skinIndices = [];
	this.boundingSphere = this.boundingBox = null;
	this.hasTangents = !1
};
THREE.Geometry.prototype = {
	computeCentroids: function() {
		var b, d, e;
		b = 0;
		for(d = this.faces.length; b < d; b++) {
			e = this.faces[b];
			e.centroid.set(0, 0, 0);
			if(e instanceof THREE.Face3) {
				e.centroid.addSelf(this.vertices[e.a].position);
				e.centroid.addSelf(this.vertices[e.b].position);
				e.centroid.addSelf(this.vertices[e.c].position);
				e.centroid.divideScalar(3)
			} else if(e instanceof THREE.Face4) {
				e.centroid.addSelf(this.vertices[e.a].position);
				e.centroid.addSelf(this.vertices[e.b].position);
				e.centroid.addSelf(this.vertices[e.c].position);
				e.centroid.addSelf(this.vertices[e.d].position);
				e.centroid.divideScalar(4)
			}
		}
	},
	computeFaceNormals: function(b) {
		var d, e, g, h, o, n, p = new THREE.Vector3,
			q = new THREE.Vector3;
		g = 0;
		for(h = this.faces.length; g < h; g++) {
			o = this.faces[g];
			if(b && o.vertexNormals.length) {
				p.set(0, 0, 0);
				d = 0;
				for(e = o.vertexNormals.length; d < e; d++) p.addSelf(o.vertexNormals[d]);
				p.divideScalar(3)
			} else {
				d = this.vertices[o.a];
				e = this.vertices[o.b];
				n = this.vertices[o.c];
				p.sub(n.position, e.position);
				q.sub(d.position, e.position);
				p.crossSelf(q)
			}
			p.isZero() ||
				p.normalize();
			o.normal.copy(p)
		}
	},
	computeVertexNormals: function() {
		var b, d, e, g;
		if(this.__tmpVertices == undefined) {
			g = this.__tmpVertices = Array(this.vertices.length);
			b = 0;
			for(d = this.vertices.length; b < d; b++) g[b] = new THREE.Vector3;
			b = 0;
			for(d = this.faces.length; b < d; b++) {
				e = this.faces[b];
				if(e instanceof THREE.Face3) e.vertexNormals = [new THREE.Vector3, new THREE.Vector3, new THREE.Vector3];
				else if(e instanceof THREE.Face4) e.vertexNormals = [new THREE.Vector3, new THREE.Vector3, new THREE.Vector3, new THREE.Vector3]
			}
		} else {
			g =
				this.__tmpVertices;
			b = 0;
			for(d = this.vertices.length; b < d; b++) g[b].set(0, 0, 0)
		}
		b = 0;
		for(d = this.faces.length; b < d; b++) {
			e = this.faces[b];
			if(e instanceof THREE.Face3) {
				g[e.a].addSelf(e.normal);
				g[e.b].addSelf(e.normal);
				g[e.c].addSelf(e.normal)
			} else if(e instanceof THREE.Face4) {
				g[e.a].addSelf(e.normal);
				g[e.b].addSelf(e.normal);
				g[e.c].addSelf(e.normal);
				g[e.d].addSelf(e.normal)
			}
		}
		b = 0;
		for(d = this.vertices.length; b < d; b++) g[b].normalize();
		b = 0;
		for(d = this.faces.length; b < d; b++) {
			e = this.faces[b];
			if(e instanceof THREE.Face3) {
				e.vertexNormals[0].copy(g[e.a]);
				e.vertexNormals[1].copy(g[e.b]);
				e.vertexNormals[2].copy(g[e.c])
			} else if(e instanceof THREE.Face4) {
				e.vertexNormals[0].copy(g[e.a]);
				e.vertexNormals[1].copy(g[e.b]);
				e.vertexNormals[2].copy(g[e.c]);
				e.vertexNormals[3].copy(g[e.d])
			}
		}
	},
	computeTangents: function() {
		function b(aa, ma, na, ga, Y, wa, qa) {
			p = aa.vertices[ma].position;
			q = aa.vertices[na].position;
			v = aa.vertices[ga].position;
			E = n[Y];
			F = n[wa];
			H = n[qa];
			I = q.x - p.x;
			M = v.x - p.x;
			N = q.y - p.y;
			V = v.y - p.y;
			L = q.z - p.z;
			sa = v.z - p.z;
			da = F.u - E.u;
			oa = H.u - E.u;
			Z = F.v - E.v;
			K = H.v - E.v;
			Ia = 1 / (da *
				K - oa * Z);
			c.set((K * I - Z * M) * Ia, (K * N - Z * V) * Ia, (K * L - Z * sa) * Ia);
			S.set((da * M - oa * I) * Ia, (da * V - oa * N) * Ia, (da * sa - oa * L) * Ia);
			Ea[ma].addSelf(c);
			Ea[na].addSelf(c);
			Ea[ga].addSelf(c);
			fa[ma].addSelf(S);
			fa[na].addSelf(S);
			fa[ga].addSelf(S)
		}
		var d, e, g, h, o, n, p, q, v, E, F, H, I, M, N, V, L, sa, da, oa, Z, K, Ia, ca, Ea = [],
			fa = [],
			c = new THREE.Vector3,
			S = new THREE.Vector3,
			pa = new THREE.Vector3,
			ra = new THREE.Vector3,
			Fa = new THREE.Vector3;
		d = 0;
		for(e = this.vertices.length; d < e; d++) {
			Ea[d] = new THREE.Vector3;
			fa[d] = new THREE.Vector3
		}
		d = 0;
		for(e = this.faces.length; d <
			e; d++) {
			o = this.faces[d];
			n = this.faceVertexUvs[0][d];
			if(o instanceof THREE.Face3) b(this, o.a, o.b, o.c, 0, 1, 2);
			else if(o instanceof THREE.Face4) {
				b(this, o.a, o.b, o.c, 0, 1, 2);
				b(this, o.a, o.b, o.d, 0, 1, 3)
			}
		}
		var ta = ["a", "b", "c", "d"];
		d = 0;
		for(e = this.faces.length; d < e; d++) {
			o = this.faces[d];
			for(g = 0; g < o.vertexNormals.length; g++) {
				Fa.copy(o.vertexNormals[g]);
				h = o[ta[g]];
				ca = Ea[h];
				pa.copy(ca);
				pa.subSelf(Fa.multiplyScalar(Fa.dot(ca))).normalize();
				ra.cross(o.vertexNormals[g], ca);
				h = ra.dot(fa[h]);
				h = h < 0 ? -1 : 1;
				o.vertexTangents[g] = new THREE.Vector4(pa.x,
					pa.y, pa.z, h)
			}
		}
		this.hasTangents = !0
	},
	computeBoundingBox: function() {
		var b;
		if(this.vertices.length > 0) {
			this.boundingBox = {
				x: [this.vertices[0].position.x, this.vertices[0].position.x],
				y: [this.vertices[0].position.y, this.vertices[0].position.y],
				z: [this.vertices[0].position.z, this.vertices[0].position.z]
			};
			for(var d = 1, e = this.vertices.length; d < e; d++) {
				b = this.vertices[d];
				if(b.position.x < this.boundingBox.x[0]) this.boundingBox.x[0] = b.position.x;
				else if(b.position.x > this.boundingBox.x[1]) this.boundingBox.x[1] = b.position.x;
				if(b.position.y < this.boundingBox.y[0]) this.boundingBox.y[0] = b.position.y;
				else if(b.position.y > this.boundingBox.y[1]) this.boundingBox.y[1] = b.position.y;
				if(b.position.z < this.boundingBox.z[0]) this.boundingBox.z[0] = b.position.z;
				else if(b.position.z > this.boundingBox.z[1]) this.boundingBox.z[1] = b.position.z
			}
		}
	},
	computeBoundingSphere: function() {
		for(var b = this.boundingSphere === null ? 0 : this.boundingSphere.radius, d = 0, e = this.vertices.length; d < e; d++) b = Math.max(b, this.vertices[d].position.length());
		this.boundingSphere = {
			radius: b
		}
	},
	computeEdgeFaces: function() {
		function b(q, v) {
			return Math.min(q, v) + "_" + Math.max(q, v)
		}

		function d(q, v, E) {
			if(q[v] === undefined) {
				q[v] = {
					set: {},
					array: []
				};
				q[v].set[E] = 1;
				q[v].array.push(E)
			} else if(q[v].set[E] === undefined) {
				q[v].set[E] = 1;
				q[v].array.push(E)
			}
		}
		var e, g, h, o, n, p = {};
		e = 0;
		for(g = this.faces.length; e < g; e++) {
			n = this.faces[e];
			if(n instanceof THREE.Face3) {
				h = b(n.a, n.b);
				d(p, h, e);
				h = b(n.b, n.c);
				d(p, h, e);
				h = b(n.a, n.c);
				d(p, h, e)
			} else if(n instanceof THREE.Face4) {
				h = b(n.b, n.d);
				d(p, h, e);
				h = b(n.a, n.b);
				d(p, h, e);
				h = b(n.a, n.d);
				d(p, h, e);
				h = b(n.b, n.c);
				d(p, h, e);
				h = b(n.c, n.d);
				d(p, h, e)
			}
		}
		e = 0;
		for(g = this.edges.length; e < g; e++) {
			n = this.edges[e];
			h = n.vertexIndices[0];
			o = n.vertexIndices[1];
			n.faceIndices = p[b(h, o)].array;
			for(h = 0; h < n.faceIndices.length; h++) {
				o = n.faceIndices[h];
				n.faces.push(this.faces[o])
			}
		}
	}
};
THREE.GeometryIdCounter = 0;
THREE.Camera = function(b, d, e, g, h) {
	THREE.Object3D.call(this);
	this.fov = b || 50;
	this.aspect = d || 1;
	this.near = e || 0.1;
	this.far = g || 2E3;
	this.target = h || new THREE.Object3D;
	this.useTarget = !0;
	this.matrixWorldInverse = new THREE.Matrix4;
	this.projectionMatrix = null;
	this.updateProjectionMatrix()
};
THREE.Camera.prototype = new THREE.Object3D;
THREE.Camera.prototype.constructor = THREE.Camera;
THREE.Camera.prototype.supr = THREE.Object3D.prototype;
THREE.Camera.prototype.translate = function(b, d) {
	this.matrix.rotateAxis(d);
	this.position.addSelf(d.multiplyScalar(b));
	this.target.position.addSelf(d.multiplyScalar(b))
};
THREE.Camera.prototype.updateProjectionMatrix = function() {
	this.projectionMatrix = THREE.Matrix4.makePerspective(this.fov, this.aspect, this.near, this.far)
};
THREE.Camera.prototype.updateMatrix = function() {
	this.update(undefined, !0)
};
THREE.Camera.prototype.update = function(b, d, e) {
	if(this.useTarget) {
		this.matrix.lookAt(this.position, this.target.position, this.up);
		this.matrix.setPosition(this.position);
		b ? this.matrixWorld.multiply(b, this.matrix) : this.matrixWorld.copy(this.matrix);
		THREE.Matrix4.makeInvert(this.matrixWorld, this.matrixWorldInverse);
		d = !0
	} else if(d || this.matrixWorldNeedsUpdate) {
		b ? this.matrixWorld.multiply(b, this.matrix) : this.matrixWorld.copy(this.matrix);
		this.matrixWorldNeedsUpdate = !1;
		d = !0;
		THREE.Matrix4.makeInvert(this.matrixWorld,
			this.matrixWorldInverse)
	}
	for(b = 0; b < this.children.length; b++) this.children[b].update(this.matrixWorld, d, e)
};
THREE.Light = function(b) {
	THREE.Object3D.call(this);
	this.color = new THREE.Color(b)
};
THREE.Light.prototype = new THREE.Object3D;
THREE.Light.prototype.constructor = THREE.Light;
THREE.Light.prototype.supr = THREE.Object3D.prototype;
THREE.AmbientLight = function(b) {
	THREE.Light.call(this, b)
};
THREE.AmbientLight.prototype = new THREE.Light;
THREE.AmbientLight.prototype.constructor = THREE.AmbientLight;
THREE.DirectionalLight = function(b, d, e) {
	THREE.Light.call(this, b);
	this.position = new THREE.Vector3(0, 1, 0);
	this.intensity = d || 1;
	this.distance = e || 0
};
THREE.DirectionalLight.prototype = new THREE.Light;
THREE.DirectionalLight.prototype.constructor = THREE.DirectionalLight;
THREE.PointLight = function(b, d, e) {
	THREE.Light.call(this, b);
	this.position = new THREE.Vector3;
	this.intensity = d || 1;
	this.distance = e || 0
};
THREE.PointLight.prototype = new THREE.Light;
THREE.PointLight.prototype.constructor = THREE.PointLight;
THREE.LensFlare = function(b, d, e, g) {
	THREE.Object3D.call(this);
	this.positionScreen = new THREE.Vector3;
	this.lensFlares = [];
	this.customUpdateCallback = undefined;
	b !== undefined && this.add(b, d, e, g)
};
THREE.LensFlare.prototype = new THREE.Object3D;
THREE.LensFlare.prototype.constructor = THREE.LensFlare;
THREE.LensFlare.prototype.supr = THREE.Object3D.prototype;
THREE.LensFlare.prototype.add = function(b, d, e, g) {
	d === undefined && (d = -1);
	e === undefined && (e = 0);
	if(g === undefined) g = THREE.BillboardBlending;
	e = Math.min(e, Math.max(0, e));
	this.lensFlares.push({
		texture: b,
		size: d,
		distance: e,
		x: 0,
		y: 0,
		z: 0,
		scale: 1,
		rotation: 1,
		opacity: 1,
		blending: g
	})
};
THREE.LensFlare.prototype.updateLensFlares = function() {
	var b, d = this.lensFlares.length,
		e, g = -this.positionScreen.x * 2,
		h = -this.positionScreen.y * 2;
	for(b = 0; b < d; b++) {
		e = this.lensFlares[b];
		e.x = this.positionScreen.x + g * e.distance;
		e.y = this.positionScreen.y + h * e.distance;
		e.wantedRotation = e.x * Math.PI * 0.25;
		e.rotation += (e.wantedRotation - e.rotation) * 0.25
	}
};
THREE.Material = function(b) {
	this.id = THREE.MaterialCounter.value++;
	b = b || {};
	this.opacity = b.opacity !== undefined ? b.opacity : 1;
	this.transparent = b.transparent !== undefined ? b.transparent : !1;
	this.blending = b.blending !== undefined ? b.blending : THREE.NormalBlending;
	this.depthTest = b.depthTest !== undefined ? b.depthTest : !0
};
THREE.NoShading = 0;
THREE.FlatShading = 1;
THREE.SmoothShading = 2;
THREE.NoColors = 0;
THREE.FaceColors = 1;
THREE.VertexColors = 2;
THREE.NormalBlending = 0;
THREE.AdditiveBlending = 1;
THREE.SubtractiveBlending = 2;
THREE.MultiplyBlending = 3;
THREE.AdditiveAlphaBlending = 4;
THREE.MaterialCounter = {
	value: 0
};
THREE.CubeReflectionMapping = function() {};
THREE.CubeRefractionMapping = function() {};
THREE.LatitudeReflectionMapping = function() {};
THREE.LatitudeRefractionMapping = function() {};
THREE.SphericalReflectionMapping = function() {};
THREE.SphericalRefractionMapping = function() {};
THREE.UVMapping = function() {};
THREE.LineBasicMaterial = function(b) {
	THREE.Material.call(this, b);
	b = b || {};
	this.color = b.color !== undefined ? new THREE.Color(b.color) : new THREE.Color(16777215);
	this.linewidth = b.linewidth !== undefined ? b.linewidth : 1;
	this.linecap = b.linecap !== undefined ? b.linecap : "round";
	this.linejoin = b.linejoin !== undefined ? b.linejoin : "round";
	this.vertexColors = b.vertexColors ? b.vertexColors : !1
};
THREE.LineBasicMaterial.prototype = new THREE.Material;
THREE.LineBasicMaterial.prototype.constructor = THREE.LineBasicMaterial;
THREE.MeshBasicMaterial = function(b) {
	THREE.Material.call(this, b);
	b = b || {};
	this.color = b.color !== undefined ? new THREE.Color(b.color) : new THREE.Color(16777215);
	this.map = b.map !== undefined ? b.map : null;
	this.lightMap = b.lightMap !== undefined ? b.lightMap : null;
	this.envMap = b.envMap !== undefined ? b.envMap : null;
	this.combine = b.combine !== undefined ? b.combine : THREE.MultiplyOperation;
	this.reflectivity = b.reflectivity !== undefined ? b.reflectivity : 1;
	this.refractionRatio = b.refractionRatio !== undefined ? b.refractionRatio : 0.98;
	this.shading =
		b.shading !== undefined ? b.shading : THREE.SmoothShading;
	this.wireframe = b.wireframe !== undefined ? b.wireframe : !1;
	this.wireframeLinewidth = b.wireframeLinewidth !== undefined ? b.wireframeLinewidth : 1;
	this.wireframeLinecap = b.wireframeLinecap !== undefined ? b.wireframeLinecap : "round";
	this.wireframeLinejoin = b.wireframeLinejoin !== undefined ? b.wireframeLinejoin : "round";
	this.vertexColors = b.vertexColors !== undefined ? b.vertexColors : !1;
	this.skinning = b.skinning !== undefined ? b.skinning : !1;
	this.morphTargets = b.morphTargets !== undefined ?
		b.morphTargets : !1
};
THREE.MeshBasicMaterial.prototype = new THREE.Material;
THREE.MeshBasicMaterial.prototype.constructor = THREE.MeshBasicMaterial;
THREE.MeshLambertMaterial = function(b) {
	THREE.Material.call(this, b);
	b = b || {};
	this.color = b.color !== undefined ? new THREE.Color(b.color) : new THREE.Color(16777215);
	this.map = b.map !== undefined ? b.map : null;
	this.lightMap = b.lightMap !== undefined ? b.lightMap : null;
	this.envMap = b.envMap !== undefined ? b.envMap : null;
	this.combine = b.combine !== undefined ? b.combine : THREE.MultiplyOperation;
	this.reflectivity = b.reflectivity !== undefined ? b.reflectivity : 1;
	this.refractionRatio = b.refractionRatio !== undefined ? b.refractionRatio : 0.98;
	this.shading =
		b.shading !== undefined ? b.shading : THREE.SmoothShading;
	this.wireframe = b.wireframe !== undefined ? b.wireframe : !1;
	this.wireframeLinewidth = b.wireframeLinewidth !== undefined ? b.wireframeLinewidth : 1;
	this.wireframeLinecap = b.wireframeLinecap !== undefined ? b.wireframeLinecap : "round";
	this.wireframeLinejoin = b.wireframeLinejoin !== undefined ? b.wireframeLinejoin : "round";
	this.vertexColors = b.vertexColors !== undefined ? b.vertexColors : !1;
	this.skinning = b.skinning !== undefined ? b.skinning : !1;
	this.morphTargets = b.morphTargets !== undefined ?
		b.morphTargets : !1
};
THREE.MeshLambertMaterial.prototype = new THREE.Material;
THREE.MeshLambertMaterial.prototype.constructor = THREE.MeshLambertMaterial;
THREE.MeshPhongMaterial = function(b) {
	THREE.Material.call(this, b);
	b = b || {};
	this.color = b.color !== undefined ? new THREE.Color(b.color) : new THREE.Color(16777215);
	this.ambient = b.ambient !== undefined ? new THREE.Color(b.ambient) : new THREE.Color(328965);
	this.specular = b.specular !== undefined ? new THREE.Color(b.specular) : new THREE.Color(1118481);
	this.shininess = b.shininess !== undefined ? b.shininess : 30;
	this.map = b.map !== undefined ? b.map : null;
	this.lightMap = b.lightMap !== undefined ? b.lightMap : null;
	this.envMap = b.envMap !== undefined ?
		b.envMap : null;
	this.combine = b.combine !== undefined ? b.combine : THREE.MultiplyOperation;
	this.reflectivity = b.reflectivity !== undefined ? b.reflectivity : 1;
	this.refractionRatio = b.refractionRatio !== undefined ? b.refractionRatio : 0.98;
	this.shading = b.shading !== undefined ? b.shading : THREE.SmoothShading;
	this.wireframe = b.wireframe !== undefined ? b.wireframe : !1;
	this.wireframeLinewidth = b.wireframeLinewidth !== undefined ? b.wireframeLinewidth : 1;
	this.wireframeLinecap = b.wireframeLinecap !== undefined ? b.wireframeLinecap : "round";
	this.wireframeLinejoin =
		b.wireframeLinejoin !== undefined ? b.wireframeLinejoin : "round";
	this.vertexColors = b.vertexColors !== undefined ? b.vertexColors : !1;
	this.skinning = b.skinning !== undefined ? b.skinning : !1;
	this.morphTargets = b.morphTargets !== undefined ? b.morphTargets : !1
};
THREE.MeshPhongMaterial.prototype = new THREE.Material;
THREE.MeshPhongMaterial.prototype.constructor = THREE.MeshPhongMaterial;
THREE.MeshDepthMaterial = function(b) {
	THREE.Material.call(this, b);
	b = b || {};
	this.shading = b.shading !== undefined ? b.shading : THREE.SmoothShading;
	this.wireframe = b.wireframe !== undefined ? b.wireframe : !1;
	this.wireframeLinewidth = b.wireframeLinewidth !== undefined ? b.wireframeLinewidth : 1
};
THREE.MeshDepthMaterial.prototype = new THREE.Material;
THREE.MeshDepthMaterial.prototype.constructor = THREE.MeshDepthMaterial;
THREE.MeshNormalMaterial = function(b) {
	THREE.Material.call(this, b);
	b = b || {};
	this.shading = b.shading ? b.shading : THREE.FlatShading;
	this.wireframe = b.wireframe ? b.wireframe : !1;
	this.wireframeLinewidth = b.wireframeLinewidth ? b.wireframeLinewidth : 1
};
THREE.MeshNormalMaterial.prototype = new THREE.Material;
THREE.MeshNormalMaterial.prototype.constructor = THREE.MeshNormalMaterial;
THREE.MeshFaceMaterial = function() {};
THREE.MeshShaderMaterial = function(b) {
	THREE.Material.call(this, b);
	b = b || {};
	this.fragmentShader = b.fragmentShader !== undefined ? b.fragmentShader : "void main() {}";
	this.vertexShader = b.vertexShader !== undefined ? b.vertexShader : "void main() {}";
	this.uniforms = b.uniforms !== undefined ? b.uniforms : {};
	this.attributes = b.attributes;
	this.shading = b.shading !== undefined ? b.shading : THREE.SmoothShading;
	this.wireframe = b.wireframe !== undefined ? b.wireframe : !1;
	this.wireframeLinewidth = b.wireframeLinewidth !== undefined ? b.wireframeLinewidth :
		1;
	this.fog = b.fog !== undefined ? b.fog : !1;
	this.lights = b.lights !== undefined ? b.lights : !1;
	this.vertexColors = b.vertexColors !== undefined ? b.vertexColors : !1;
	this.skinning = b.skinning !== undefined ? b.skinning : !1;
	this.morphTargets = b.morphTargets !== undefined ? b.morphTargets : !1
};
THREE.MeshShaderMaterial.prototype = new THREE.Material;
THREE.MeshShaderMaterial.prototype.constructor = THREE.MeshShaderMaterial;
THREE.ParticleBasicMaterial = function(b) {
	THREE.Material.call(this, b);
	b = b || {};
	this.color = b.color !== undefined ? new THREE.Color(b.color) : new THREE.Color(16777215);
	this.map = b.map !== undefined ? b.map : null;
	this.size = b.size !== undefined ? b.size : 1;
	this.sizeAttenuation = b.sizeAttenuation !== undefined ? b.sizeAttenuation : !0;
	this.vertexColors = b.vertexColors !== undefined ? b.vertexColors : !1
};
THREE.ParticleBasicMaterial.prototype = new THREE.Material;
THREE.ParticleBasicMaterial.prototype.constructor = THREE.ParticleBasicMaterial;
THREE.ShadowVolumeDynamicMaterial = function(b) {
	THREE.Material.call(this, b);
	b = b || {};
	this.color = b.color !== undefined ? new THREE.Color(b.color) : new THREE.Color(16777215);
	this.map = b.map !== undefined ? b.map : null;
	this.lightMap = b.lightMap !== undefined ? b.lightMap : null;
	this.envMap = b.envMap !== undefined ? b.envMap : null;
	this.combine = b.combine !== undefined ? b.combine : THREE.MultiplyOperation;
	this.reflectivity = b.reflectivity !== undefined ? b.reflectivity : 1;
	this.refractionRatio = b.refractionRatio !== undefined ? b.refractionRatio :
		0.98;
	this.shading = b.shading !== undefined ? b.shading : THREE.SmoothShading;
	this.wireframe = b.wireframe !== undefined ? b.wireframe : !1;
	this.wireframeLinewidth = b.wireframeLinewidth !== undefined ? b.wireframeLinewidth : 1;
	this.wireframeLinecap = b.wireframeLinecap !== undefined ? b.wireframeLinecap : "round";
	this.wireframeLinejoin = b.wireframeLinejoin !== undefined ? b.wireframeLinejoin : "round";
	this.vertexColors = b.vertexColors !== undefined ? b.vertexColors : !1;
	this.skinning = b.skinning !== undefined ? b.skinning : !1;
	this.morphTargets = b.morphTargets !==
		undefined ? b.morphTargets : !1
};
THREE.ShadowVolumeDynamicMaterial.prototype = new THREE.Material;
THREE.ShadowVolumeDynamicMaterial.prototype.constructor = THREE.ShadowVolumeDynamicMaterial;
THREE.Texture = function(b, d, e, g, h, o) {
	this.image = b;
	this.mapping = d !== undefined ? d : new THREE.UVMapping;
	this.wrapS = e !== undefined ? e : THREE.ClampToEdgeWrapping;
	this.wrapT = g !== undefined ? g : THREE.ClampToEdgeWrapping;
	this.magFilter = h !== undefined ? h : THREE.LinearFilter;
	this.minFilter = o !== undefined ? o : THREE.LinearMipMapLinearFilter;
	this.needsUpdate = !1
};
THREE.Texture.prototype = {
	clone: function() {
		return new THREE.Texture(this.image, this.mapping, this.wrapS, this.wrapT, this.magFilter, this.minFilter)
	}
};
THREE.MultiplyOperation = 0;
THREE.MixOperation = 1;
THREE.RepeatWrapping = 0;
THREE.ClampToEdgeWrapping = 1;
THREE.MirroredRepeatWrapping = 2;
THREE.NearestFilter = 3;
THREE.NearestMipMapNearestFilter = 4;
THREE.NearestMipMapLinearFilter = 5;
THREE.LinearFilter = 6;
THREE.LinearMipMapNearestFilter = 7;
THREE.LinearMipMapLinearFilter = 8;
THREE.ByteType = 9;
THREE.UnsignedByteType = 10;
THREE.ShortType = 11;
THREE.UnsignedShortType = 12;
THREE.IntType = 13;
THREE.UnsignedIntType = 14;
THREE.FloatType = 15;
THREE.AlphaFormat = 16;
THREE.RGBFormat = 17;
THREE.RGBAFormat = 18;
THREE.LuminanceFormat = 19;
THREE.LuminanceAlphaFormat = 20;
THREE.Particle = function(b) {
	THREE.Object3D.call(this);
	this.materials = b instanceof Array ? b : [b];
	this.matrixAutoUpdate = !1
};
THREE.Particle.prototype = new THREE.Object3D;
THREE.Particle.prototype.constructor = THREE.Particle;
THREE.ParticleSystem = function(b, d) {
	THREE.Object3D.call(this);
	this.geometry = b;
	this.materials = d instanceof Array ? d : [d];
	this.sortParticles = !1
};
THREE.ParticleSystem.prototype = new THREE.Object3D;
THREE.ParticleSystem.prototype.constructor = THREE.ParticleSystem;
THREE.Line = function(b, d, e) {
	THREE.Object3D.call(this);
	this.geometry = b;
	this.materials = d instanceof Array ? d : [d];
	this.type = e != undefined ? e : THREE.LineStrip
};
THREE.LineStrip = 0;
THREE.LinePieces = 1;
THREE.Line.prototype = new THREE.Object3D;
THREE.Line.prototype.constructor = THREE.Line;
THREE.Mesh = function(b, d) {
	THREE.Object3D.call(this);
	this.geometry = b;
	this.materials = d && d.length ? d : [d];
	this.flipSided = !1;
	this.doubleSided = !1;
	this.overdraw = !1;
	if(this.geometry) {
		this.geometry.boundingSphere || this.geometry.computeBoundingSphere();
		this.boundRadius = b.boundingSphere.radius;
		if(this.geometry.morphTargets.length) {
			this.morphTargetBase = -1;
			this.morphTargetForcedOrder = [];
			this.morphTargetInfluences = [];
			this.morphTargetDictionary = {};
			for(var e = 0; e < this.geometry.morphTargets.length; e++) {
				this.morphTargetInfluences.push(0);
				this.morphTargetDictionary[this.geometry.morphTargets[e].name] = e
			}
		}
	}
};
THREE.Mesh.prototype = new THREE.Object3D;
THREE.Mesh.prototype.constructor = THREE.Mesh;
THREE.Mesh.prototype.supr = THREE.Object3D.prototype;
THREE.Mesh.prototype.getMorphTargetIndexByName = function(b) {
	if(this.morphTargetDictionary[b] !== undefined) return this.morphTargetDictionary[b];
	console.log("THREE.Mesh.getMorphTargetIndexByName: morph target " + b + " does not exist. Returning 0.");
	return 0
};
THREE.Bone = function(b) {
	THREE.Object3D.call(this);
	this.skin = b;
	this.skinMatrix = new THREE.Matrix4;
	this.hasNoneBoneChildren = !1
};
THREE.Bone.prototype = new THREE.Object3D;
THREE.Bone.prototype.constructor = THREE.Bone;
THREE.Bone.prototype.supr = THREE.Object3D.prototype;
THREE.Bone.prototype.update = function(b, d, e) {
	this.matrixAutoUpdate && (d |= this.updateMatrix());
	if(d || this.matrixWorldNeedsUpdate) {
		b ? this.skinMatrix.multiply(b, this.matrix) : this.skinMatrix.copy(this.matrix);
		this.matrixWorldNeedsUpdate = !1;
		d = !0
	}
	var g, h = this.children.length;
	if(this.hasNoneBoneChildren) {
		this.matrixWorld.multiply(this.skin.matrixWorld, this.skinMatrix);
		for(g = 0; g < h; g++) {
			b = this.children[g];
			b instanceof THREE.Bone ? b.update(this.skinMatrix, d, e) : b.update(this.matrixWorld, !0, e)
		}
	} else
		for(g = 0; g < h; g++) this.children[g].update(this.skinMatrix,
			d, e)
};
THREE.Bone.prototype.addChild = function(b) {
	if(this.children.indexOf(b) === -1) {
		b.parent !== undefined && b.parent.removeChild(b);
		b.parent = this;
		this.children.push(b);
		if(!(b instanceof THREE.Bone)) this.hasNoneBoneChildren = !0
	}
};
THREE.SkinnedMesh = function(b, d) {
	THREE.Mesh.call(this, b, d);
	this.identityMatrix = new THREE.Matrix4;
	this.bones = [];
	this.boneMatrices = [];
	var e, g, h, o, n, p;
	if(this.geometry.bones !== undefined) {
		for(e = 0; e < this.geometry.bones.length; e++) {
			h = this.geometry.bones[e];
			o = h.pos;
			n = h.rotq;
			p = h.scl;
			g = this.addBone();
			g.name = h.name;
			g.position.set(o[0], o[1], o[2]);
			g.quaternion.set(n[0], n[1], n[2], n[3]);
			g.useQuaternion = !0;
			p !== undefined ? g.scale.set(p[0], p[1], p[2]) : g.scale.set(1, 1, 1)
		}
		for(e = 0; e < this.bones.length; e++) {
			h = this.geometry.bones[e];
			g = this.bones[e];
			h.parent === -1 ? this.addChild(g) : this.bones[h.parent].addChild(g)
		}
		this.boneMatrices = new Float32Array(16 * this.bones.length);
		this.pose()
	}
};
THREE.SkinnedMesh.prototype = new THREE.Mesh;
THREE.SkinnedMesh.prototype.constructor = THREE.SkinnedMesh;
THREE.SkinnedMesh.prototype.update = function(b, d, e) {
	if(this.visible) {
		this.matrixAutoUpdate && (d |= this.updateMatrix());
		if(d || this.matrixWorldNeedsUpdate) {
			b ? this.matrixWorld.multiply(b, this.matrix) : this.matrixWorld.copy(this.matrix);
			this.matrixWorldNeedsUpdate = !1;
			d = !0
		}
		var g, h = this.children.length;
		for(g = 0; g < h; g++) {
			b = this.children[g];
			b instanceof THREE.Bone ? b.update(this.identityMatrix, !1, e) : b.update(this.matrixWorld, d, e)
		}
		e = this.bones.length;
		ba = this.bones;
		bm = this.boneMatrices;
		for(d = 0; d < e; d++) ba[d].skinMatrix.flattenToArrayOffset(bm,
			d * 16)
	}
};
THREE.SkinnedMesh.prototype.addBone = function(b) {
	b === undefined && (b = new THREE.Bone(this));
	this.bones.push(b);
	return b
};
THREE.SkinnedMesh.prototype.pose = function() {
	this.update(undefined, !0);
	for(var b, d = [], e = 0; e < this.bones.length; e++) {
		b = this.bones[e];
		d.push(THREE.Matrix4.makeInvert(b.skinMatrix));
		b.skinMatrix.flattenToArrayOffset(this.boneMatrices, e * 16)
	}
	if(this.geometry.skinVerticesA === undefined) {
		this.geometry.skinVerticesA = [];
		this.geometry.skinVerticesB = [];
		var g;
		for(b = 0; b < this.geometry.skinIndices.length; b++) {
			e = this.geometry.vertices[b].position;
			var h = this.geometry.skinIndices[b].x,
				o = this.geometry.skinIndices[b].y;
			g = new THREE.Vector3(e.x, e.y, e.z);
			this.geometry.skinVerticesA.push(d[h].multiplyVector3(g));
			g = new THREE.Vector3(e.x, e.y, e.z);
			this.geometry.skinVerticesB.push(d[o].multiplyVector3(g));
			if(this.geometry.skinWeights[b].x + this.geometry.skinWeights[b].y !== 1) {
				e = (1 - (this.geometry.skinWeights[b].x + this.geometry.skinWeights[b].y)) * 0.5;
				this.geometry.skinWeights[b].x += e;
				this.geometry.skinWeights[b].y += e
			}
		}
	}
};
THREE.Ribbon = function(b, d) {
	THREE.Object3D.call(this);
	this.geometry = b;
	this.materials = d instanceof Array ? d : [d];
	this.flipSided = !1;
	this.doubleSided = !1
};
THREE.Ribbon.prototype = new THREE.Object3D;
THREE.Ribbon.prototype.constructor = THREE.Ribbon;
THREE.Sound = function(b, d, e, g) {
	THREE.Object3D.call(this);
	this.isLoaded = !1;
	this.isAddedToDOM = !1;
	this.isPlaying = !1;
	this.duration = -1;
	this.radius = d !== undefined ? Math.abs(d) : 100;
	this.volume = Math.min(1, Math.max(0, e !== undefined ? e : 1));
	this.domElement = document.createElement("audio");
	this.domElement.volume = 0;
	this.domElement.pan = 0;
	this.domElement.loop = g !== undefined ? g : !0;
	this.sources = b instanceof Array ? b : [b];
	var h;
	e = this.sources.length;
	for(b = 0; b < e; b++) {
		d = this.sources[b];
		d.toLowerCase();
		if(d.indexOf(".mp3") !== -1) h =
			"audio/mpeg";
		else if(d.indexOf(".ogg") !== -1) h = "audio/ogg";
		else d.indexOf(".wav") !== -1 && (h = "audio/wav");
		if(this.domElement.canPlayType(h)) {
			h = document.createElement("source");
			h.src = this.sources[b];
			this.domElement.THREESound = this;
			this.domElement.appendChild(h);
			this.domElement.addEventListener("canplay", this.onLoad, !0);
			this.domElement.load();
			break
		}
	}
};
THREE.Sound.prototype = new THREE.Object3D;
THREE.Sound.prototype.constructor = THREE.Sound;
THREE.Sound.prototype.supr = THREE.Object3D.prototype;
THREE.Sound.prototype.onLoad = function() {
	var b = this.THREESound;
	if(!b.isLoaded) {
		this.removeEventListener("canplay", this.onLoad, !0);
		b.isLoaded = !0;
		b.duration = this.duration;
		b.isPlaying && b.play()
	}
};
THREE.Sound.prototype.addToDOM = function(b) {
	this.isAddedToDOM = !0;
	b.appendChild(this.domElement)
};
THREE.Sound.prototype.play = function(b) {
	this.isPlaying = !0;
	if(this.isLoaded) {
		this.domElement.play();
		if(b) this.domElement.currentTime = b % this.duration
	}
};
THREE.Sound.prototype.pause = function() {
	this.isPlaying = !1;
	this.domElement.pause()
};
THREE.Sound.prototype.stop = function() {
	this.isPlaying = !1;
	this.domElement.pause();
	this.domElement.currentTime = 0
};
THREE.Sound.prototype.calculateVolumeAndPan = function(b) {
	b = b.length();
	this.domElement.volume = b <= this.radius ? this.volume * (1 - b / this.radius) : 0
};
THREE.Sound.prototype.update = function(b, d, e) {
	if(this.matrixAutoUpdate) {
		this.matrix.setPosition(this.position);
		d = !0
	}
	if(d || this.matrixWorldNeedsUpdate) {
		b ? this.matrixWorld.multiply(b, this.matrix) : this.matrixWorld.copy(this.matrix);
		this.matrixWorldNeedsUpdate = !1;
		d = !0
	}
	var g = this.children.length;
	for(b = 0; b < g; b++) this.children[b].update(this.matrixWorld, d, e)
};
THREE.LOD = function() {
	THREE.Object3D.call(this);
	this.LODs = []
};
THREE.LOD.prototype = new THREE.Object3D;
THREE.LOD.prototype.constructor = THREE.LOD;
THREE.LOD.prototype.supr = THREE.Object3D.prototype;
THREE.LOD.prototype.add = function(b, d) {
	d === undefined && (d = 0);
	d = Math.abs(d);
	for(var e = 0; e < this.LODs.length; e++)
		if(d < this.LODs[e].visibleAtDistance) break;
	this.LODs.splice(e, 0, {
		visibleAtDistance: d,
		object3D: b
	});
	this.addChild(b)
};
THREE.LOD.prototype.update = function(b, d, e) {
	this.matrixAutoUpdate && (d |= this.updateMatrix());
	if(d || this.matrixWorldNeedsUpdate) {
		b ? this.matrixWorld.multiply(b, this.matrix) : this.matrixWorld.copy(this.matrix);
		this.matrixWorldNeedsUpdate = !1;
		d = !0
	}
	if(this.LODs.length > 1) {
		b = e.matrixWorldInverse;
		b = -(b.n31 * this.position.x + b.n32 * this.position.y + b.n33 * this.position.z + b.n34);
		this.LODs[0].object3D.visible = !0;
		for(var g = 1; g < this.LODs.length; g++)
			if(b >= this.LODs[g].visibleAtDistance) {
				this.LODs[g - 1].object3D.visible = !1;
				this.LODs[g].object3D.visible = !0
			} else break;
		for(; g < this.LODs.length; g++) this.LODs[g].object3D.visible = !1
	}
	for(b = 0; b < this.children.length; b++) this.children[b].update(this.matrixWorld, d, e)
};
THREE.ShadowVolume = function(b, d) {
	if(b instanceof THREE.Mesh) {
		THREE.Mesh.call(this, b.geometry, d ? [new THREE.ShadowVolumeDynamicMaterial] : [new THREE.ShadowVolumeDynamicMaterial]);
		b.addChild(this)
	} else THREE.Mesh.call(this, b, d ? [new THREE.ShadowVolumeDynamicMaterial] : [new THREE.ShadowVolumeDynamicMaterial]);
	this.calculateShadowVolumeGeometry()
};
THREE.ShadowVolume.prototype = new THREE.Mesh;
THREE.ShadowVolume.prototype.constructor = THREE.ShadowVolume;
THREE.ShadowVolume.prototype.supr = THREE.Mesh.prototype;
THREE.ShadowVolume.prototype.calculateShadowVolumeGeometry = function() {
	if(this.geometry.edges && this.geometry.edges.length) {
		var b, d, e, g, h, o, n, p, q, v, E, F, H, I, M = new THREE.Geometry;
		M.vertices = this.geometry.vertices;
		g = M.faces = this.geometry.faces;
		var N = M.egdes = this.geometry.edges,
			V = M.edgeFaces = [];
		h = 0;
		var L = [];
		b = 0;
		for(d = g.length; b < d; b++) {
			e = g[b];
			L.push(h);
			h += e instanceof THREE.Face3 ? 3 : 4;
			e.vertexNormals[0] = e.normal;
			e.vertexNormals[1] = e.normal;
			e.vertexNormals[2] = e.normal;
			if(e instanceof THREE.Face4) e.vertexNormals[3] =
				e.normal
		}
		b = 0;
		for(d = N.length; b < d; b++) {
			p = N[b];
			e = p.faces[0];
			g = p.faces[1];
			h = p.faceIndices[0];
			o = p.faceIndices[1];
			n = p.vertexIndices[0];
			p = p.vertexIndices[1];
			if(e.a === n) {
				q = "a";
				E = L[h] + 0
			} else if(e.b === n) {
				q = "b";
				E = L[h] + 1
			} else if(e.c === n) {
				q = "c";
				E = L[h] + 2
			} else if(e.d === n) {
				q = "d";
				E = L[h] + 3
			}
			if(e.a === p) {
				q += "a";
				F = L[h] + 0
			} else if(e.b === p) {
				q += "b";
				F = L[h] + 1
			} else if(e.c === p) {
				q += "c";
				F = L[h] + 2
			} else if(e.d === p) {
				q += "d";
				F = L[h] + 3
			}
			if(g.a === n) {
				v = "a";
				H = L[o] + 0
			} else if(g.b === n) {
				v = "b";
				H = L[o] + 1
			} else if(g.c === n) {
				v = "c";
				H = L[o] + 2
			} else if(g.d ===
				n) {
				v = "d";
				H = L[o] + 3
			}
			if(g.a === p) {
				v += "a";
				I = L[o] + 0
			} else if(g.b === p) {
				v += "b";
				I = L[o] + 1
			} else if(g.c === p) {
				v += "c";
				I = L[o] + 2
			} else if(g.d === p) {
				v += "d";
				I = L[o] + 3
			}
			if(q === "ac" || q === "ad" || q === "ca" || q === "da") {
				if(E > F) {
					e = E;
					E = F;
					F = e
				}
			} else if(E < F) {
				e = E;
				E = F;
				F = e
			}
			if(v === "ac" || v === "ad" || v === "ca" || v === "da") {
				if(H > I) {
					e = H;
					H = I;
					I = e
				}
			} else if(H < I) {
				e = H;
				H = I;
				I = e
			}
			e = new THREE.Face4(E, F, H, I);
			e.normal.set(1, 0, 0);
			V.push(e)
		}
		this.geometry = M
	} else this.calculateShadowVolumeGeometryWithoutEdgeInfo(this.geometry)
};
THREE.ShadowVolume.prototype.calculateShadowVolumeGeometryWithoutEdgeInfo = function(b) {
	this.geometry = new THREE.Geometry;
	this.geometry.boundingSphere = b.boundingSphere;
	this.geometry.edgeFaces = [];
	var d = this.geometry.vertices,
		e = this.geometry.faces,
		g = this.geometry.edgeFaces,
		h = b.faces;
	b = b.vertices;
	var o = h.length,
		n, p, q, v, E, F = ["a", "b", "c", "d"];
	for(q = 0; q < o; q++) {
		p = d.length;
		n = h[q];
		if(n instanceof THREE.Face4) {
			v = 4;
			p = new THREE.Face4(p, p + 1, p + 2, p + 3)
		} else {
			v = 3;
			p = new THREE.Face3(p, p + 1, p + 2)
		}
		p.normal.copy(n.normal);
		e.push(p);
		for(p = 0; p < v; p++) {
			E = b[n[F[p]]];
			d.push(new THREE.Vertex(E.position.clone()))
		}
	}
	for(o = 0; o < h.length - 1; o++) {
		b = e[o];
		for(n = o + 1; n < h.length; n++) {
			p = e[n];
			p = this.facesShareEdge(d, b, p);
			if(p !== undefined) {
				p = new THREE.Face4(p.indices[0], p.indices[3], p.indices[2], p.indices[1]);
				p.normal.set(1, 0, 0);
				g.push(p)
			}
		}
	}
};
THREE.ShadowVolume.prototype.facesShareEdge = function(b, d, e) {
	var g, h, o, n, p, q, v, E, F, H, I, M, N, V = 0,
		L = ["a", "b", "c", "d"];
	g = d instanceof THREE.Face4 ? 4 : 3;
	h = e instanceof THREE.Face4 ? 4 : 3;
	for(M = 0; M < g; M++) {
		o = d[L[M]];
		p = b[o];
		for(N = 0; N < h; N++) {
			n = e[L[N]];
			q = b[n];
			if(Math.abs(p.position.x - q.position.x) < 1.0E-4 && Math.abs(p.position.y - q.position.y) < 1.0E-4 && Math.abs(p.position.z - q.position.z) < 1.0E-4) {
				V++;
				if(V === 1) {
					v = p;
					E = q;
					F = o;
					H = n;
					I = L[M]
				}
				if(V === 2) {
					I += L[M];
					return I === "ad" || I === "ac" ? {
						faces: [d, e],
						vertices: [v, E, q, p],
						indices: [F,
							H, n, o
						],
						vertexTypes: [1, 2, 2, 1],
						extrudable: !0
					} : {
						faces: [d, e],
						vertices: [v, p, q, E],
						indices: [F, o, n, H],
						vertexTypes: [1, 1, 2, 2],
						extrudable: !0
					}
				}
			}
		}
	}
};
THREE.Scene = function() {
	THREE.Object3D.call(this);
	this.matrixAutoUpdate = !1;
	this.fog = null;
	this.objects = [];
	this.lights = [];
	this.sounds = [];
	this.__objectsAdded = [];
	this.__objectsRemoved = []
};
THREE.Scene.prototype = new THREE.Object3D;
THREE.Scene.prototype.constructor = THREE.Scene;
THREE.Scene.prototype.supr = THREE.Object3D.prototype;
THREE.Scene.prototype.addChild = function(b) {
	this.supr.addChild.call(this, b);
	this.addChildRecurse(b)
};
THREE.Scene.prototype.addChildRecurse = function(b) {
	if(b instanceof THREE.Light) this.lights.indexOf(b) === -1 && this.lights.push(b);
	else if(b instanceof THREE.Sound) this.sounds.indexOf(b) === -1 && this.sounds.push(b);
	else if(!(b instanceof THREE.Camera || b instanceof THREE.Bone) && this.objects.indexOf(b) === -1) {
		this.objects.push(b);
		this.__objectsAdded.push(b)
	}
	for(var d = 0; d < b.children.length; d++) this.addChildRecurse(b.children[d])
};
THREE.Scene.prototype.removeChild = function(b) {
	this.supr.removeChild.call(this, b);
	this.removeChildRecurse(b)
};
THREE.Scene.prototype.removeChildRecurse = function(b) {
	if(b instanceof THREE.Light) {
		var d = this.lights.indexOf(b);
		d !== -1 && this.lights.splice(d, 1)
	} else if(b instanceof THREE.Sound) {
		d = this.sounds.indexOf(b);
		d !== -1 && this.sounds.splice(d, 1)
	} else if(!(b instanceof THREE.Camera)) {
		d = this.objects.indexOf(b);
		if(d !== -1) {
			this.objects.splice(d, 1);
			this.__objectsRemoved.push(b)
		}
	}
	for(d = 0; d < b.children.length; d++) this.removeChildRecurse(b.children[d])
};
THREE.Scene.prototype.addObject = THREE.Scene.prototype.addChild;
THREE.Scene.prototype.removeObject = THREE.Scene.prototype.removeChild;
THREE.Scene.prototype.addLight = THREE.Scene.prototype.addChild;
THREE.Scene.prototype.removeLight = THREE.Scene.prototype.removeChild;
THREE.Fog = function(b, d, e) {
	this.color = new THREE.Color(b);
	this.near = d || 1;
	this.far = e || 1E3
};
THREE.FogExp2 = function(b, d) {
	this.color = new THREE.Color(b);
	this.density = d !== undefined ? d : 2.5E-4
};
THREE.Projector = function() {
	function b() {
		var c = q[p] = q[p] || new THREE.RenderableVertex;
		p++;
		return c
	}

	function d(c, S) {
		return S.z - c.z
	}

	function e(c, S) {
		var pa = 0,
			ra = 1,
			Fa = c.z + c.w,
			ta = S.z + S.w,
			aa = -c.z + c.w,
			ma = -S.z + S.w;
		if(Fa >= 0 && ta >= 0 && aa >= 0 && ma >= 0) return !0;
		else if(Fa < 0 && ta < 0 || aa < 0 && ma < 0) return !1;
		else {
			if(Fa < 0) pa = Math.max(pa, Fa / (Fa - ta));
			else ta < 0 && (ra = Math.min(ra, Fa / (Fa - ta)));
			if(aa < 0) pa = Math.max(pa, aa / (aa - ma));
			else ma < 0 && (ra = Math.min(ra, aa / (aa - ma)));
			if(ra < pa) return !1;
			else {
				c.lerpSelf(S, pa);
				S.lerpSelf(c, 1 - ra);
				return !0
			}
		}
	}
	var g, h, o = [],
		n, p, q = [],
		v, E, F = [],
		H, I = [],
		M, N, V = [],
		L, sa, da = [],
		oa = new THREE.Vector4,
		Z = new THREE.Vector4,
		K = new THREE.Matrix4,
		Ia = new THREE.Matrix4,
		ca = [new THREE.Vector4, new THREE.Vector4, new THREE.Vector4, new THREE.Vector4, new THREE.Vector4, new THREE.Vector4],
		Ea = new THREE.Vector4,
		fa = new THREE.Vector4;
	this.projectVector = function(c, S) {
		K.multiply(S.projectionMatrix, S.matrixWorldInverse);
		K.multiplyVector3(c);
		return c
	};
	this.unprojectVector = function(c, S) {
		K.multiply(S.matrixWorld, THREE.Matrix4.makeInvert(S.projectionMatrix));
		K.multiplyVector3(c);
		return c
	};
	this.projectObjects = function(c, S, pa) {
		S = [];
		var ra, Fa, ta;
		h = 0;
		Fa = c.objects;
		c = 0;
		for(ra = Fa.length; c < ra; c++) {
			ta = Fa[c];
			var aa;
			if(!(aa = !ta.visible))
				if(aa = ta instanceof THREE.Mesh) {
					a: {
						aa = void 0;
						for(var ma = ta.matrixWorld, na = -ta.geometry.boundingSphere.radius * Math.max(ta.scale.x, Math.max(ta.scale.y, ta.scale.z)), ga = 0; ga < 6; ga++) {
							aa = ca[ga].x * ma.n14 + ca[ga].y * ma.n24 + ca[ga].z * ma.n34 + ca[ga].w;
							if(aa <= na) {
								aa = !1;
								break a
							}
						}
						aa = !0
					}
					aa = !aa
				}
			if(!aa) {
				aa = o[h] = o[h] || new THREE.RenderableObject;
				h++;
				g = aa;
				oa.copy(ta.position);
				K.multiplyVector3(oa);
				g.object = ta;
				g.z = oa.z;
				S.push(g)
			}
		}
		pa && S.sort(d);
		return S
	};
	this.projectScene = function(c, S, pa) {
		var ra = [],
			Fa = S.near,
			ta = S.far,
			aa, ma, na, ga, Y, wa, qa, ya, za, $, Pa, Ta, Xa, Ua, Sa, R, J;
		sa = N = H = E = 0;
		S.matrixAutoUpdate && S.updateMatrix();
		c.update(undefined, !1, S);
		K.multiply(S.projectionMatrix, S.matrixWorldInverse);
		ca[0].set(K.n41 - K.n11, K.n42 - K.n12, K.n43 - K.n13, K.n44 - K.n14);
		ca[1].set(K.n41 + K.n11, K.n42 + K.n12, K.n43 + K.n13, K.n44 + K.n14);
		ca[2].set(K.n41 + K.n21, K.n42 + K.n22, K.n43 + K.n23,
			K.n44 + K.n24);
		ca[3].set(K.n41 - K.n21, K.n42 - K.n22, K.n43 - K.n23, K.n44 - K.n24);
		ca[4].set(K.n41 - K.n31, K.n42 - K.n32, K.n43 - K.n33, K.n44 - K.n34);
		ca[5].set(K.n41 + K.n31, K.n42 + K.n32, K.n43 + K.n33, K.n44 + K.n34);
		for(aa = 0; aa < 6; aa++) {
			za = ca[aa];
			za.divideScalar(Math.sqrt(za.x * za.x + za.y * za.y + za.z * za.z))
		}
		za = this.projectObjects(c, S, !0);
		c = 0;
		for(aa = za.length; c < aa; c++) {
			$ = za[c].object;
			if($.visible) {
				Pa = $.matrixWorld;
				Ta = $.matrixRotationWorld;
				Xa = $.materials;
				Ua = $.overdraw;
				p = 0;
				if($ instanceof THREE.Mesh) {
					Sa = $.geometry;
					ga = Sa.vertices;
					R = Sa.faces;
					Sa = Sa.faceVertexUvs;
					ma = 0;
					for(na = ga.length; ma < na; ma++) {
						n = b();
						n.positionWorld.copy(ga[ma].position);
						Pa.multiplyVector3(n.positionWorld);
						n.positionScreen.copy(n.positionWorld);
						K.multiplyVector4(n.positionScreen);
						n.positionScreen.x /= n.positionScreen.w;
						n.positionScreen.y /= n.positionScreen.w;
						n.visible = n.positionScreen.z > Fa && n.positionScreen.z < ta
					}
					ga = 0;
					for(ma = R.length; ga < ma; ga++) {
						na = R[ga];
						if(na instanceof THREE.Face3) {
							Y = q[na.a];
							wa = q[na.b];
							qa = q[na.c];
							if(Y.visible && wa.visible && qa.visible && ($.doubleSided ||
									$.flipSided != (qa.positionScreen.x - Y.positionScreen.x) * (wa.positionScreen.y - Y.positionScreen.y) - (qa.positionScreen.y - Y.positionScreen.y) * (wa.positionScreen.x - Y.positionScreen.x) < 0)) {
								ya = F[E] = F[E] || new THREE.RenderableFace3;
								E++;
								v = ya;
								v.v1.copy(Y);
								v.v2.copy(wa);
								v.v3.copy(qa)
							} else continue
						} else if(na instanceof THREE.Face4) {
							Y = q[na.a];
							wa = q[na.b];
							qa = q[na.c];
							ya = q[na.d];
							if(Y.visible && wa.visible && qa.visible && ya.visible && ($.doubleSided || $.flipSided != ((ya.positionScreen.x - Y.positionScreen.x) * (wa.positionScreen.y -
									Y.positionScreen.y) - (ya.positionScreen.y - Y.positionScreen.y) * (wa.positionScreen.x - Y.positionScreen.x) < 0 || (wa.positionScreen.x - qa.positionScreen.x) * (ya.positionScreen.y - qa.positionScreen.y) - (wa.positionScreen.y - qa.positionScreen.y) * (ya.positionScreen.x - qa.positionScreen.x) < 0))) {
								J = I[H] = I[H] || new THREE.RenderableFace4;
								H++;
								v = J;
								v.v1.copy(Y);
								v.v2.copy(wa);
								v.v3.copy(qa);
								v.v4.copy(ya)
							} else continue
						}
						v.normalWorld.copy(na.normal);
						Ta.multiplyVector3(v.normalWorld);
						v.centroidWorld.copy(na.centroid);
						Pa.multiplyVector3(v.centroidWorld);
						v.centroidScreen.copy(v.centroidWorld);
						K.multiplyVector3(v.centroidScreen);
						qa = na.vertexNormals;
						Y = 0;
						for(wa = qa.length; Y < wa; Y++) {
							ya = v.vertexNormalsWorld[Y];
							ya.copy(qa[Y]);
							Ta.multiplyVector3(ya)
						}
						Y = 0;
						for(wa = Sa.length; Y < wa; Y++)
							if(J = Sa[Y][ga]) {
								qa = 0;
								for(ya = J.length; qa < ya; qa++) v.uvs[Y][qa] = J[qa]
							}
						v.meshMaterials = Xa;
						v.faceMaterials = na.materials;
						v.overdraw = Ua;
						v.z = v.centroidScreen.z;
						ra.push(v)
					}
				} else if($ instanceof THREE.Line) {
					Ia.multiply(K, Pa);
					ga = $.geometry.vertices;
					Y = b();
					Y.positionScreen.copy(ga[0].position);
					Ia.multiplyVector4(Y.positionScreen);
					ma = 1;
					for(na = ga.length; ma < na; ma++) {
						Y = b();
						Y.positionScreen.copy(ga[ma].position);
						Ia.multiplyVector4(Y.positionScreen);
						wa = q[p - 2];
						Ea.copy(Y.positionScreen);
						fa.copy(wa.positionScreen);
						if(e(Ea, fa)) {
							Ea.multiplyScalar(1 / Ea.w);
							fa.multiplyScalar(1 / fa.w);
							Pa = V[N] = V[N] || new THREE.RenderableLine;
							N++;
							M = Pa;
							M.v1.positionScreen.copy(Ea);
							M.v2.positionScreen.copy(fa);
							M.z = Math.max(Ea.z, fa.z);
							M.materials = $.materials;
							ra.push(M)
						}
					}
				} else if($ instanceof THREE.Particle) {
					Z.set($.position.x,
						$.position.y, $.position.z, 1);
					K.multiplyVector4(Z);
					Z.z /= Z.w;
					if(Z.z > 0 && Z.z < 1) {
						Pa = da[sa] = da[sa] || new THREE.RenderableParticle;
						sa++;
						L = Pa;
						L.x = Z.x / Z.w;
						L.y = Z.y / Z.w;
						L.z = Z.z;
						L.rotation = $.rotation.z;
						L.scale.x = $.scale.x * Math.abs(L.x - (Z.x + S.projectionMatrix.n11) / (Z.w + S.projectionMatrix.n14));
						L.scale.y = $.scale.y * Math.abs(L.y - (Z.y + S.projectionMatrix.n22) / (Z.w + S.projectionMatrix.n24));
						L.materials = $.materials;
						ra.push(L)
					}
				}
			}
		}
		pa && ra.sort(d);
		return ra
	}
};
THREE.SoundRenderer = function() {
	this.volume = 1;
	this.domElement = document.createElement("div");
	this.domElement.id = "THREESound";
	this.cameraPosition = new THREE.Vector3;
	this.soundPosition = new THREE.Vector3;
	this.render = function(b, d, e) {
		e && b.update(undefined, !1, d);
		e = b.sounds;
		var g, h = e.length;
		for(g = 0; g < h; g++) {
			b = e[g];
			this.soundPosition.set(b.matrixWorld.n14, b.matrixWorld.n24, b.matrixWorld.n34);
			this.soundPosition.subSelf(d.position);
			if(b.isPlaying && b.isLoaded) {
				b.isAddedToDOM || b.addToDOM(this.domElement);
				b.calculateVolumeAndPan(this.soundPosition)
			}
		}
	}
};
THREE.ShaderChunk = {
	fog_pars_fragment: "#ifdef USE_FOG\nuniform vec3 fogColor;\n#ifdef FOG_EXP2\nuniform float fogDensity;\n#else\nuniform float fogNear;\nuniform float fogFar;\n#endif\n#endif",
	fog_fragment: "#ifdef USE_FOG\nfloat depth = gl_FragCoord.z / gl_FragCoord.w;\n#ifdef FOG_EXP2\nconst float LOG2 = 1.442695;\nfloat fogFactor = exp2( - fogDensity * fogDensity * depth * depth * LOG2 );\nfogFactor = 1.0 - clamp( fogFactor, 0.0, 1.0 );\n#else\nfloat fogFactor = smoothstep( fogNear, fogFar, depth );\n#endif\ngl_FragColor = mix( gl_FragColor, vec4( fogColor, gl_FragColor.w ), fogFactor );\n#endif",
	envmap_pars_fragment: "#ifdef USE_ENVMAP\nvarying vec3 vReflect;\nuniform float reflectivity;\nuniform samplerCube envMap;\nuniform int combine;\n#endif",
	envmap_fragment: "#ifdef USE_ENVMAP\nvec4 cubeColor = textureCube( envMap, vec3( -vReflect.x, vReflect.yz ) );\nif ( combine == 1 ) {\ngl_FragColor = vec4( mix( gl_FragColor.xyz, cubeColor.xyz, reflectivity ), opacity );\n} else {\ngl_FragColor = gl_FragColor * cubeColor;\n}\n#endif",
	envmap_pars_vertex: "#ifdef USE_ENVMAP\nvarying vec3 vReflect;\nuniform float refractionRatio;\nuniform bool useRefract;\n#endif",
	envmap_vertex: "#ifdef USE_ENVMAP\nvec4 mPosition = objectMatrix * vec4( position, 1.0 );\nvec3 nWorld = mat3( objectMatrix[0].xyz, objectMatrix[1].xyz, objectMatrix[2].xyz ) * normal;\nif ( useRefract ) {\nvReflect = refract( normalize( mPosition.xyz - cameraPosition ), normalize( nWorld.xyz ), refractionRatio );\n} else {\nvReflect = reflect( normalize( mPosition.xyz - cameraPosition ), normalize( nWorld.xyz ) );\n}\n#endif",
	map_particle_pars_fragment: "#ifdef USE_MAP\nuniform sampler2D map;\n#endif",
	map_particle_fragment: "#ifdef USE_MAP\ngl_FragColor = gl_FragColor * texture2D( map, gl_PointCoord );\n#endif",
	map_pars_fragment: "#ifdef USE_MAP\nvarying vec2 vUv;\nuniform sampler2D map;\n#endif",
	map_pars_vertex: "#ifdef USE_MAP\nvarying vec2 vUv;\n#endif",
	map_fragment: "#ifdef USE_MAP\ngl_FragColor = gl_FragColor * texture2D( map, vUv );\n#endif",
	map_vertex: "#ifdef USE_MAP\nvUv = uv;\n#endif",
	lightmap_pars_fragment: "#ifdef USE_LIGHTMAP\nvarying vec2 vUv2;\nuniform sampler2D lightMap;\n#endif",
	lightmap_pars_vertex: "#ifdef USE_LIGHTMAP\nvarying vec2 vUv2;\n#endif",
	lightmap_fragment: "#ifdef USE_LIGHTMAP\ngl_FragColor = gl_FragColor * texture2D( lightMap, vUv2 );\n#endif",
	lightmap_vertex: "#ifdef USE_LIGHTMAP\nvUv2 = uv2;\n#endif",
	lights_pars_vertex: "uniform bool enableLighting;\nuniform vec3 ambientLightColor;\n#if MAX_DIR_LIGHTS > 0\nuniform vec3 directionalLightColor[ MAX_DIR_LIGHTS ];\nuniform vec3 directionalLightDirection[ MAX_DIR_LIGHTS ];\n#endif\n#if MAX_POINT_LIGHTS > 0\nuniform vec3 pointLightColor[ MAX_POINT_LIGHTS ];\nuniform vec3 pointLightPosition[ MAX_POINT_LIGHTS ];\nuniform float pointLightDistance[ MAX_POINT_LIGHTS ];\n#ifdef PHONG\nvarying vec4 vPointLight[ MAX_POINT_LIGHTS ];\n#endif\n#endif",
	lights_vertex: "if ( !enableLighting ) {\nvLightWeighting = vec3( 1.0 );\n} else {\nvLightWeighting = ambientLightColor;\n#if MAX_DIR_LIGHTS > 0\nfor( int i = 0; i < MAX_DIR_LIGHTS; i++ ) {\nvec4 lDirection = viewMatrix * vec4( directionalLightDirection[ i ], 0.0 );\nfloat directionalLightWeighting = max( dot( transformedNormal, normalize( lDirection.xyz ) ), 0.0 );\nvLightWeighting += directionalLightColor[ i ] * directionalLightWeighting;\n}\n#endif\n#if MAX_POINT_LIGHTS > 0\nfor( int i = 0; i < MAX_POINT_LIGHTS; i++ ) {\nvec4 lPosition = viewMatrix * vec4( pointLightPosition[ i ], 1.0 );\nvec3 lVector = lPosition.xyz - mvPosition.xyz;\nfloat lDistance = 1.0;\nif ( pointLightDistance[ i ] > 0.0 )\nlDistance = 1.0 - min( ( length( lVector ) / pointLightDistance[ i ] ), 1.0 );\nlVector = normalize( lVector );\nfloat pointLightWeighting = max( dot( transformedNormal, lVector ), 0.0 );\nvLightWeighting += pointLightColor[ i ] * pointLightWeighting * lDistance;\n#ifdef PHONG\nvPointLight[ i ] = vec4( lVector, lDistance );\n#endif\n}\n#endif\n}",
	lights_pars_fragment: "#if MAX_DIR_LIGHTS > 0\nuniform vec3 directionalLightDirection[ MAX_DIR_LIGHTS ];\n#endif\n#if MAX_POINT_LIGHTS > 0\nvarying vec4 vPointLight[ MAX_POINT_LIGHTS ];\n#endif\nvarying vec3 vViewPosition;\nvarying vec3 vNormal;",
	lights_fragment: "vec3 normal = normalize( vNormal );\nvec3 viewPosition = normalize( vViewPosition );\nvec4 mColor = vec4( diffuse, opacity );\nvec4 mSpecular = vec4( specular, opacity );\n#if MAX_POINT_LIGHTS > 0\nvec4 pointDiffuse  = vec4( 0.0 );\nvec4 pointSpecular = vec4( 0.0 );\nfor ( int i = 0; i < MAX_POINT_LIGHTS; i ++ ) {\nvec3 pointVector = normalize( vPointLight[ i ].xyz );\nvec3 pointHalfVector = normalize( vPointLight[ i ].xyz + vViewPosition );\nfloat pointDistance = vPointLight[ i ].w;\nfloat pointDotNormalHalf = dot( normal, pointHalfVector );\nfloat pointDiffuseWeight = max( dot( normal, pointVector ), 0.0 );\nfloat pointSpecularWeight = 0.0;\nif ( pointDotNormalHalf >= 0.0 )\npointSpecularWeight = pow( pointDotNormalHalf, shininess );\npointDiffuse  += mColor * pointDiffuseWeight * pointDistance;\npointSpecular += mSpecular * pointSpecularWeight * pointDistance;\n}\n#endif\n#if MAX_DIR_LIGHTS > 0\nvec4 dirDiffuse  = vec4( 0.0 );\nvec4 dirSpecular = vec4( 0.0 );\nfor( int i = 0; i < MAX_DIR_LIGHTS; i++ ) {\nvec4 lDirection = viewMatrix * vec4( directionalLightDirection[ i ], 0.0 );\nvec3 dirVector = normalize( lDirection.xyz );\nvec3 dirHalfVector = normalize( lDirection.xyz + vViewPosition );\nfloat dirDotNormalHalf = dot( normal, dirHalfVector );\nfloat dirDiffuseWeight = max( dot( normal, dirVector ), 0.0 );\nfloat dirSpecularWeight = 0.0;\nif ( dirDotNormalHalf >= 0.0 )\ndirSpecularWeight = pow( dirDotNormalHalf, shininess );\ndirDiffuse  += mColor * dirDiffuseWeight;\ndirSpecular += mSpecular * dirSpecularWeight;\n}\n#endif\nvec4 totalLight = vec4( ambient, opacity );\n#if MAX_DIR_LIGHTS > 0\ntotalLight += dirDiffuse + dirSpecular;\n#endif\n#if MAX_POINT_LIGHTS > 0\ntotalLight += pointDiffuse + pointSpecular;\n#endif\ngl_FragColor = gl_FragColor * totalLight;",
	color_pars_fragment: "#ifdef USE_COLOR\nvarying vec3 vColor;\n#endif",
	color_fragment: "#ifdef USE_COLOR\ngl_FragColor = gl_FragColor * vec4( vColor, opacity );\n#endif",
	color_pars_vertex: "#ifdef USE_COLOR\nvarying vec3 vColor;\n#endif",
	color_vertex: "#ifdef USE_COLOR\nvColor = color;\n#endif",
	skinning_pars_vertex: "#ifdef USE_SKINNING\nuniform mat4 boneGlobalMatrices[ MAX_BONES ];\n#endif",
	skinning_vertex: "#ifdef USE_SKINNING\ngl_Position  = ( boneGlobalMatrices[ int( skinIndex.x ) ] * skinVertexA ) * skinWeight.x;\ngl_Position += ( boneGlobalMatrices[ int( skinIndex.y ) ] * skinVertexB ) * skinWeight.y;\ngl_Position  = projectionMatrix * viewMatrix * objectMatrix * gl_Position;\n#endif",
	morphtarget_pars_vertex: "#ifdef USE_MORPHTARGETS\nuniform float morphTargetInfluences[ 8 ];\n#endif",
	morphtarget_vertex: "#ifdef USE_MORPHTARGETS\nvec3 morphed = vec3( 0.0, 0.0, 0.0 );\nmorphed += ( morphTarget0 - position ) * morphTargetInfluences[ 0 ];\nmorphed += ( morphTarget1 - position ) * morphTargetInfluences[ 1 ];\nmorphed += ( morphTarget2 - position ) * morphTargetInfluences[ 2 ];\nmorphed += ( morphTarget3 - position ) * morphTargetInfluences[ 3 ];\nmorphed += ( morphTarget4 - position ) * morphTargetInfluences[ 4 ];\nmorphed += ( morphTarget5 - position ) * morphTargetInfluences[ 5 ];\nmorphed += ( morphTarget6 - position ) * morphTargetInfluences[ 6 ];\nmorphed += ( morphTarget7 - position ) * morphTargetInfluences[ 7 ];\nmorphed += position;\ngl_Position = projectionMatrix * modelViewMatrix * vec4( morphed, 1.0 );\n#endif",
	default_vertex: "#ifndef USE_MORPHTARGETS\n#ifndef USE_SKINNING\ngl_Position = projectionMatrix * mvPosition;\n#endif\n#endif"
};
THREE.UniformsUtils = {
	merge: function(b) {
		var d, e, g, h = {};
		for(d = 0; d < b.length; d++) {
			g = this.clone(b[d]);
			for(e in g) h[e] = g[e]
		}
		return h
	},
	clone: function(b) {
		var d, e, g, h = {};
		for(d in b) {
			h[d] = {};
			for(e in b[d]) {
				g = b[d][e];
				h[d][e] = g instanceof THREE.Color || g instanceof THREE.Vector3 || g instanceof THREE.Texture ? g.clone() : g
			}
		}
		return h
	}
};
THREE.UniformsLib = {
	common: {
		diffuse: {
			type: "c",
			value: new THREE.Color(15658734)
		},
		opacity: {
			type: "f",
			value: 1
		},
		map: {
			type: "t",
			value: 0,
			texture: null
		},
		lightMap: {
			type: "t",
			value: 2,
			texture: null
		},
		envMap: {
			type: "t",
			value: 1,
			texture: null
		},
		useRefract: {
			type: "i",
			value: 0
		},
		reflectivity: {
			type: "f",
			value: 1
		},
		refractionRatio: {
			type: "f",
			value: 0.98
		},
		combine: {
			type: "i",
			value: 0
		},
		fogDensity: {
			type: "f",
			value: 2.5E-4
		},
		fogNear: {
			type: "f",
			value: 1
		},
		fogFar: {
			type: "f",
			value: 2E3
		},
		fogColor: {
			type: "c",
			value: new THREE.Color(16777215)
		},
		morphTargetInfluences: {
			type: "f",
			value: 0
		}
	},
	lights: {
		enableLighting: {
			type: "i",
			value: 1
		},
		ambientLightColor: {
			type: "fv",
			value: []
		},
		directionalLightDirection: {
			type: "fv",
			value: []
		},
		directionalLightColor: {
			type: "fv",
			value: []
		},
		pointLightColor: {
			type: "fv",
			value: []
		},
		pointLightPosition: {
			type: "fv",
			value: []
		},
		pointLightDistance: {
			type: "fv1",
			value: []
		}
	},
	particle: {
		psColor: {
			type: "c",
			value: new THREE.Color(15658734)
		},
		opacity: {
			type: "f",
			value: 1
		},
		size: {
			type: "f",
			value: 1
		},
		scale: {
			type: "f",
			value: 1
		},
		map: {
			type: "t",
			value: 0,
			texture: null
		},
		fogDensity: {
			type: "f",
			value: 2.5E-4
		},
		fogNear: {
			type: "f",
			value: 1
		},
		fogFar: {
			type: "f",
			value: 2E3
		},
		fogColor: {
			type: "c",
			value: new THREE.Color(16777215)
		}
	}
};
THREE.ShaderLib = {
	lensFlareVertexTexture: {
		vertexShader: "uniform \tvec3 \tscreenPosition;\nuniform\tvec2\tscale;\nuniform\tfloat\trotation;\nuniform    int     renderType;\nuniform\tsampler2D\tocclusionMap;\nattribute \tvec2 \tposition;\nattribute  vec2\tUV;\nvarying\tvec2\tvUV;\nvarying\tfloat\tvVisibility;\nvoid main(void)\n{\nvUV = UV;\nvec2 pos = position;\nif( renderType == 2 ) {\nvec4 visibility = texture2D( occlusionMap, vec2( 0.1, 0.1 )) +\ntexture2D( occlusionMap, vec2( 0.5, 0.1 )) +\ntexture2D( occlusionMap, vec2( 0.9, 0.1 )) +\ntexture2D( occlusionMap, vec2( 0.9, 0.5 )) +\ntexture2D( occlusionMap, vec2( 0.9, 0.9 )) +\ntexture2D( occlusionMap, vec2( 0.5, 0.9 )) +\ntexture2D( occlusionMap, vec2( 0.1, 0.9 )) +\ntexture2D( occlusionMap, vec2( 0.1, 0.5 )) +\ntexture2D( occlusionMap, vec2( 0.5, 0.5 ));\nvVisibility = (       visibility.r / 9.0 ) *\n( 1.0 - visibility.g / 9.0 ) *\n(       visibility.b / 9.0 ) *\n( 1.0 - visibility.a / 9.0 );\npos.x = cos( rotation ) * position.x - sin( rotation ) * position.y;\npos.y = sin( rotation ) * position.x + cos( rotation ) * position.y;\n}\ngl_Position = vec4(( pos * scale + screenPosition.xy ).xy, screenPosition.z, 1.0 );\n}",
		fragmentShader: "#ifdef GL_ES\nprecision highp float;\n#endif\nuniform\tsampler2D\tmap;\nuniform\tfloat\t\topacity;\nuniform    int         renderType;\nvarying\tvec2\t\tvUV;\nvarying\tfloat\t\tvVisibility;\nvoid main( void )\n{\nif( renderType == 0 ) {\ngl_FragColor = vec4( 1.0, 0.0, 1.0, 0.0 );\n} else if( renderType == 1 ) {\ngl_FragColor = texture2D( map, vUV );\n} else {\nvec4 color = texture2D( map, vUV );\ncolor.a *= opacity * vVisibility;\ngl_FragColor = color;\n}\n}"
	},
	lensFlare: {
		vertexShader: "uniform \tvec3 \tscreenPosition;\nuniform\tvec2\tscale;\nuniform\tfloat\trotation;\nuniform    int     renderType;\nattribute \tvec2 \tposition;\nattribute  vec2\tUV;\nvarying\tvec2\tvUV;\nvoid main(void)\n{\nvUV = UV;\nvec2 pos = position;\nif( renderType == 2 ) {\npos.x = cos( rotation ) * position.x - sin( rotation ) * position.y;\npos.y = sin( rotation ) * position.x + cos( rotation ) * position.y;\n}\ngl_Position = vec4(( pos * scale + screenPosition.xy ).xy, screenPosition.z, 1.0 );\n}",
		fragmentShader: "#ifdef GL_ES\nprecision highp float;\n#endif\nuniform\tsampler2D\tmap;\nuniform\tsampler2D\tocclusionMap;\nuniform\tfloat\t\topacity;\nuniform    int         renderType;\nvarying\tvec2\t\tvUV;\nvoid main( void )\n{\nif( renderType == 0 ) {\ngl_FragColor = vec4( texture2D( map, vUV ).rgb, 0.0 );\n} else if( renderType == 1 ) {\ngl_FragColor = texture2D( map, vUV );\n} else {\nfloat visibility = texture2D( occlusionMap, vec2( 0.5, 0.1 )).a +\ntexture2D( occlusionMap, vec2( 0.9, 0.5 )).a +\ntexture2D( occlusionMap, vec2( 0.5, 0.9 )).a +\ntexture2D( occlusionMap, vec2( 0.1, 0.5 )).a;\nvisibility = ( 1.0 - visibility / 4.0 );\nvec4 color = texture2D( map, vUV );\ncolor.a *= opacity * visibility;\ngl_FragColor = color;\n}\n}"
	},
	sprite: {
		vertexShader: "uniform\tint\t\tuseScreenCoordinates;\nuniform    int     affectedByDistance;\nuniform\tvec3\tscreenPosition;\nuniform \tmat4 \tmodelViewMatrix;\nuniform \tmat4 \tprojectionMatrix;\nuniform    float   rotation;\nuniform    vec2    scale;\nuniform    vec2    alignment;\nuniform    vec2    uvOffset;\nuniform\tvec2    uvScale;\nattribute \tvec2 \tposition;\nattribute  vec2\tuv;\nvarying\tvec2\tvUV;\nvoid main(void)\n{\nvUV = uvOffset + uv * uvScale;\nvec2 alignedPosition = position + alignment;\nvec2 rotatedPosition;\nrotatedPosition.x = ( cos( rotation ) * alignedPosition.x - sin( rotation ) * alignedPosition.y ) * scale.x;\nrotatedPosition.y = ( sin( rotation ) * alignedPosition.x + cos( rotation ) * alignedPosition.y ) * scale.y;\nvec4 finalPosition;\nif( useScreenCoordinates != 0 ) {\nfinalPosition = vec4( screenPosition.xy + rotatedPosition, screenPosition.z, 1.0 );\n} else {\nfinalPosition = projectionMatrix * modelViewMatrix * vec4( 0.0, 0.0, 0.0, 1.0 );\nfinalPosition.xy += rotatedPosition * ( affectedByDistance == 1 ? 1.0 : finalPosition.z );\n}\ngl_Position = finalPosition;\n}",
		fragmentShader: "#ifdef GL_ES\nprecision highp float;\n#endif\nuniform\tsampler2D\tmap;\nuniform\tfloat\t\topacity;\nvarying\tvec2\t\tvUV;\nvoid main( void )\n{\nvec4 color = texture2D( map, vUV );\ncolor.a *= opacity;\ngl_FragColor = color;\n}"
	},
	shadowPost: {
		vertexShader: "uniform \tmat4 \tprojectionMatrix;\nattribute \tvec3 \tposition;\nvoid main(void)\n{\ngl_Position = projectionMatrix * vec4( position, 1.0 );\n}",
		fragmentShader: "#ifdef GL_ES\nprecision highp float;\n#endif\nuniform \tfloat \tdarkness;\nvoid main( void )\n{\ngl_FragColor = vec4( 0, 0, 0, darkness );\n}"
	},
	shadowVolumeDynamic: {
		uniforms: {
			directionalLightDirection: {
				type: "fv",
				value: []
			}
		},
		vertexShader: "uniform \tvec3 \tdirectionalLightDirection;\nvoid main() {\nvec4 pos      = objectMatrix * vec4( position, 1.0 );\nvec3 norm     = mat3( objectMatrix[0].xyz, objectMatrix[1].xyz, objectMatrix[2].xyz ) * normal;\nvec4 extruded = vec4( directionalLightDirection * 5000.0 * step( 0.0, dot( directionalLightDirection, norm )), 0.0 );\ngl_Position   = projectionMatrix * viewMatrix * ( pos + extruded );\n}",
		fragmentShader: "void main() {\ngl_FragColor = vec4( 1.0 );\n}"
	},
	depth: {
		uniforms: {
			mNear: {
				type: "f",
				value: 1
			},
			mFar: {
				type: "f",
				value: 2E3
			},
			opacity: {
				type: "f",
				value: 1
			}
		},
		fragmentShader: "uniform float mNear;\nuniform float mFar;\nuniform float opacity;\nvoid main() {\nfloat depth = gl_FragCoord.z / gl_FragCoord.w;\nfloat color = 1.0 - smoothstep( mNear, mFar, depth );\ngl_FragColor = vec4( vec3( color ), opacity );\n}",
		vertexShader: "void main() {\ngl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );\n}"
	},
	normal: {
		uniforms: {
			opacity: {
				type: "f",
				value: 1
			}
		},
		fragmentShader: "uniform float opacity;\nvarying vec3 vNormal;\nvoid main() {\ngl_FragColor = vec4( 0.5 * normalize( vNormal ) + 0.5, opacity );\n}",
		vertexShader: "varying vec3 vNormal;\nvoid main() {\nvec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );\nvNormal = normalize( normalMatrix * normal );\ngl_Position = projectionMatrix * mvPosition;\n}"
	},
	basic: {
		uniforms: THREE.UniformsLib.common,
		fragmentShader: ["uniform vec3 diffuse;\nuniform float opacity;", THREE.ShaderChunk.color_pars_fragment, THREE.ShaderChunk.map_pars_fragment,
			THREE.ShaderChunk.lightmap_pars_fragment, THREE.ShaderChunk.envmap_pars_fragment, THREE.ShaderChunk.fog_pars_fragment, "void main() {\ngl_FragColor = vec4( diffuse, opacity );", THREE.ShaderChunk.map_fragment, THREE.ShaderChunk.lightmap_fragment, THREE.ShaderChunk.color_fragment, THREE.ShaderChunk.envmap_fragment, THREE.ShaderChunk.fog_fragment, "}"
		].join("\n"),
		vertexShader: [THREE.ShaderChunk.map_pars_vertex, THREE.ShaderChunk.lightmap_pars_vertex, THREE.ShaderChunk.envmap_pars_vertex, THREE.ShaderChunk.color_pars_vertex,
			THREE.ShaderChunk.skinning_pars_vertex, THREE.ShaderChunk.morphtarget_pars_vertex, "void main() {\nvec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );", THREE.ShaderChunk.map_vertex, THREE.ShaderChunk.lightmap_vertex, THREE.ShaderChunk.envmap_vertex, THREE.ShaderChunk.color_vertex, THREE.ShaderChunk.skinning_vertex, THREE.ShaderChunk.morphtarget_vertex, THREE.ShaderChunk.default_vertex, "}"
		].join("\n")
	},
	lambert: {
		uniforms: THREE.UniformsUtils.merge([THREE.UniformsLib.common, THREE.UniformsLib.lights]),
		fragmentShader: ["uniform vec3 diffuse;\nuniform float opacity;\nvarying vec3 vLightWeighting;", THREE.ShaderChunk.color_pars_fragment, THREE.ShaderChunk.map_pars_fragment, THREE.ShaderChunk.lightmap_pars_fragment, THREE.ShaderChunk.envmap_pars_fragment, THREE.ShaderChunk.fog_pars_fragment, "void main() {\ngl_FragColor = vec4( diffuse, opacity );\ngl_FragColor = gl_FragColor * vec4( vLightWeighting, 1.0 );", THREE.ShaderChunk.map_fragment, THREE.ShaderChunk.lightmap_fragment, THREE.ShaderChunk.color_fragment,
			THREE.ShaderChunk.envmap_fragment, THREE.ShaderChunk.fog_fragment, "}"
		].join("\n"),
		vertexShader: ["varying vec3 vLightWeighting;", THREE.ShaderChunk.map_pars_vertex, THREE.ShaderChunk.lightmap_pars_vertex, THREE.ShaderChunk.envmap_pars_vertex, THREE.ShaderChunk.lights_pars_vertex, THREE.ShaderChunk.color_pars_vertex, THREE.ShaderChunk.skinning_pars_vertex, THREE.ShaderChunk.morphtarget_pars_vertex, "void main() {\nvec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );", THREE.ShaderChunk.map_vertex, THREE.ShaderChunk.lightmap_vertex,
			THREE.ShaderChunk.envmap_vertex, THREE.ShaderChunk.color_vertex, "vec3 transformedNormal = normalize( normalMatrix * normal );", THREE.ShaderChunk.lights_vertex, THREE.ShaderChunk.skinning_vertex, THREE.ShaderChunk.morphtarget_vertex, THREE.ShaderChunk.default_vertex, "}"
		].join("\n")
	},
	phong: {
		uniforms: THREE.UniformsUtils.merge([THREE.UniformsLib.common, THREE.UniformsLib.lights, {
			ambient: {
				type: "c",
				value: new THREE.Color(328965)
			},
			specular: {
				type: "c",
				value: new THREE.Color(1118481)
			},
			shininess: {
				type: "f",
				value: 30
			}
		}]),
		fragmentShader: ["uniform vec3 diffuse;\nuniform float opacity;\nuniform vec3 ambient;\nuniform vec3 specular;\nuniform float shininess;\nvarying vec3 vLightWeighting;", THREE.ShaderChunk.color_pars_fragment, THREE.ShaderChunk.map_pars_fragment, THREE.ShaderChunk.lightmap_pars_fragment, THREE.ShaderChunk.envmap_pars_fragment, THREE.ShaderChunk.fog_pars_fragment, THREE.ShaderChunk.lights_pars_fragment, "void main() {\ngl_FragColor = vec4( vLightWeighting, 1.0 );", THREE.ShaderChunk.lights_fragment, THREE.ShaderChunk.map_fragment,
			THREE.ShaderChunk.lightmap_fragment, THREE.ShaderChunk.color_fragment, THREE.ShaderChunk.envmap_fragment, THREE.ShaderChunk.fog_fragment, "}"
		].join("\n"),
		vertexShader: ["#define PHONG\nvarying vec3 vLightWeighting;\nvarying vec3 vViewPosition;\nvarying vec3 vNormal;", THREE.ShaderChunk.map_pars_vertex, THREE.ShaderChunk.lightmap_pars_vertex, THREE.ShaderChunk.envmap_pars_vertex, THREE.ShaderChunk.lights_pars_vertex, THREE.ShaderChunk.color_pars_vertex, THREE.ShaderChunk.skinning_pars_vertex, THREE.ShaderChunk.morphtarget_pars_vertex,
			"void main() {\nvec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );", THREE.ShaderChunk.map_vertex, THREE.ShaderChunk.lightmap_vertex, THREE.ShaderChunk.envmap_vertex, THREE.ShaderChunk.color_vertex, "#ifndef USE_ENVMAP\nvec4 mPosition = objectMatrix * vec4( position, 1.0 );\n#endif\nvViewPosition = cameraPosition - mPosition.xyz;\nvec3 transformedNormal = normalize( normalMatrix * normal );\nvNormal = transformedNormal;", THREE.ShaderChunk.lights_vertex, THREE.ShaderChunk.skinning_vertex, THREE.ShaderChunk.morphtarget_vertex,
			THREE.ShaderChunk.default_vertex, "}"
		].join("\n")
	},
	particle_basic: {
		uniforms: THREE.UniformsLib.particle,
		fragmentShader: ["uniform vec3 psColor;\nuniform float opacity;", THREE.ShaderChunk.color_pars_fragment, THREE.ShaderChunk.map_particle_pars_fragment, THREE.ShaderChunk.fog_pars_fragment, "void main() {\ngl_FragColor = vec4( psColor, opacity );", THREE.ShaderChunk.map_particle_fragment, THREE.ShaderChunk.color_fragment, THREE.ShaderChunk.fog_fragment, "}"].join("\n"),
		vertexShader: ["uniform float size;\nuniform float scale;",
			THREE.ShaderChunk.color_pars_vertex, "void main() {", THREE.ShaderChunk.color_vertex, "vec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );\n#ifdef USE_SIZEATTENUATION\ngl_PointSize = size * ( scale / length( mvPosition.xyz ) );\n#else\ngl_PointSize = size;\n#endif\ngl_Position = projectionMatrix * mvPosition;\n}"
		].join("\n")
	}
};
THREE.WebGLRenderer = function(b) {
	function d(f, s, j) {
		var k, m, w, x = f.vertices,
			u = x.length,
			A = f.colors,
			t = A.length,
			y = f.__vertexArray,
			z = f.__colorArray,
			D = f.__sortArray,
			B = f.__dirtyVertices,
			O = f.__dirtyColors;
		if(j.sortParticles) {
			Pa.multiplySelf(j.matrixWorld);
			for(k = 0; k < u; k++) {
				m = x[k].position;
				Ua.copy(m);
				Pa.multiplyVector3(Ua);
				D[k] = [Ua.z, k]
			}
			D.sort(function(W, P) {
				return P[0] - W[0]
			});
			for(k = 0; k < u; k++) {
				m = x[D[k][1]].position;
				w = k * 3;
				y[w] = m.x;
				y[w + 1] = m.y;
				y[w + 2] = m.z
			}
			for(k = 0; k < t; k++) {
				w = k * 3;
				color = A[D[k][1]];
				z[w] = color.r;
				z[w + 1] =
					color.g;
				z[w + 2] = color.b
			}
		} else {
			if(B)
				for(k = 0; k < u; k++) {
					m = x[k].position;
					w = k * 3;
					y[w] = m.x;
					y[w + 1] = m.y;
					y[w + 2] = m.z
				}
			if(O)
				for(k = 0; k < t; k++) {
					color = A[k];
					w = k * 3;
					z[w] = color.r;
					z[w + 1] = color.g;
					z[w + 2] = color.b
				}
		}
		if(B || j.sortParticles) {
			c.bindBuffer(c.ARRAY_BUFFER, f.__webglVertexBuffer);
			c.bufferData(c.ARRAY_BUFFER, y, s)
		}
		if(O || j.sortParticles) {
			c.bindBuffer(c.ARRAY_BUFFER, f.__webglColorBuffer);
			c.bufferData(c.ARRAY_BUFFER, z, s)
		}
	}

	function e(f, s, j, k, m) {
		k.program || aa.initMaterial(k, s, j, m);
		var w = k.program,
			x = w.uniforms,
			u = k.uniforms;
		if(w != ra) {
			c.useProgram(w);
			ra = w
		}
		c.uniformMatrix4fv(x.projectionMatrix, !1, Ta);
		if(j && (k instanceof THREE.MeshBasicMaterial || k instanceof THREE.MeshLambertMaterial || k instanceof THREE.MeshPhongMaterial || k instanceof THREE.LineBasicMaterial || k instanceof THREE.ParticleBasicMaterial || k.fog)) {
			u.fogColor.value = j.color;
			if(j instanceof THREE.Fog) {
				u.fogNear.value = j.near;
				u.fogFar.value = j.far
			} else if(j instanceof THREE.FogExp2) u.fogDensity.value = j.density
		}
		if(k instanceof THREE.MeshPhongMaterial || k instanceof THREE.MeshLambertMaterial ||
			k.lights) {
			var A, t, y = 0,
				z = 0,
				D = 0,
				B, O, W, P, X = Sa,
				Ga = X.directional.colors,
				T = X.directional.positions,
				Q = X.point.colors,
				U = X.point.positions,
				ua = X.point.distances,
				r = 0,
				G = 0;
			j = t = P = 0;
			for(A = s.length; j < A; j++) {
				t = s[j];
				B = t.color;
				O = t.position;
				W = t.intensity;
				P = t.distance;
				if(t instanceof THREE.AmbientLight) {
					y += B.r;
					z += B.g;
					D += B.b
				} else if(t instanceof THREE.DirectionalLight) {
					P = r * 3;
					Ga[P] = B.r * W;
					Ga[P + 1] = B.g * W;
					Ga[P + 2] = B.b * W;
					T[P] = O.x;
					T[P + 1] = O.y;
					T[P + 2] = O.z;
					r += 1
				} else if(t instanceof THREE.PointLight) {
					t = G * 3;
					Q[t] = B.r * W;
					Q[t + 1] = B.g * W;
					Q[t + 2] = B.b * W;
					U[t] = O.x;
					U[t + 1] = O.y;
					U[t + 2] = O.z;
					ua[G] = P;
					G += 1
				}
			}
			for(j = r * 3; j < Ga.length; j++) Ga[j] = 0;
			for(j = G * 3; j < Q.length; j++) Q[j] = 0;
			X.point.length = G;
			X.directional.length = r;
			X.ambient[0] = y;
			X.ambient[1] = z;
			X.ambient[2] = D;
			j = Sa;
			u.enableLighting.value = j.directional.length + j.point.length;
			u.ambientLightColor.value = j.ambient;
			u.directionalLightColor.value = j.directional.colors;
			u.directionalLightDirection.value = j.directional.positions;
			u.pointLightColor.value = j.point.colors;
			u.pointLightPosition.value = j.point.positions;
			u.pointLightDistance.value = j.point.distances
		}
		if(k instanceof THREE.MeshBasicMaterial || k instanceof THREE.MeshLambertMaterial || k instanceof THREE.MeshPhongMaterial) {
			u.diffuse.value = k.color;
			u.opacity.value = k.opacity;
			u.map.texture = k.map;
			u.lightMap.texture = k.lightMap;
			u.envMap.texture = k.envMap;
			u.reflectivity.value = k.reflectivity;
			u.refractionRatio.value = k.refractionRatio;
			u.combine.value = k.combine;
			u.useRefract.value = k.envMap && k.envMap.mapping instanceof THREE.CubeRefractionMapping
		}
		if(k instanceof THREE.LineBasicMaterial) {
			u.diffuse.value =
				k.color;
			u.opacity.value = k.opacity
		} else if(k instanceof THREE.ParticleBasicMaterial) {
			u.psColor.value = k.color;
			u.opacity.value = k.opacity;
			u.size.value = k.size;
			u.scale.value = S.height / 2;
			u.map.texture = k.map
		} else if(k instanceof THREE.MeshPhongMaterial) {
			u.ambient.value = k.ambient;
			u.specular.value = k.specular;
			u.shininess.value = k.shininess
		} else if(k instanceof THREE.MeshDepthMaterial) {
			u.mNear.value = f.near;
			u.mFar.value = f.far;
			u.opacity.value = k.opacity
		} else if(k instanceof THREE.MeshNormalMaterial) u.opacity.value =
			k.opacity;
		for(var i in u)
			if(z = w.uniforms[i]) {
				A = u[i];
				y = A.type;
				j = A.value;
				if(y == "i") c.uniform1i(z, j);
				else if(y == "f") c.uniform1f(z, j);
				else if(y == "fv1") c.uniform1fv(z, j);
				else if(y == "fv") c.uniform3fv(z, j);
				else if(y == "v2") c.uniform2f(z, j.x, j.y);
				else if(y == "v3") c.uniform3f(z, j.x, j.y, j.z);
				else if(y == "v4") c.uniform4f(z, j.x, j.y, j.z, j.w);
				else if(y == "c") c.uniform3f(z, j.r, j.g, j.b);
				else if(y == "t") {
					c.uniform1i(z, j);
					if(A = A.texture)
						if(A.image instanceof Array && A.image.length == 6) {
							if(A.image.length == 6) {
								if(A.needsUpdate) {
									if(A.__webglInit) {
										c.bindTexture(c.TEXTURE_CUBE_MAP,
											A.image.__webglTextureCube);
										for(y = 0; y < 6; ++y) c.texSubImage2D(c.TEXTURE_CUBE_MAP_POSITIVE_X + y, 0, 0, 0, c.RGBA, c.UNSIGNED_BYTE, A.image[y])
									} else {
										A.image.__webglTextureCube = c.createTexture();
										c.bindTexture(c.TEXTURE_CUBE_MAP, A.image.__webglTextureCube);
										for(y = 0; y < 6; ++y) c.texImage2D(c.TEXTURE_CUBE_MAP_POSITIVE_X + y, 0, c.RGBA, c.RGBA, c.UNSIGNED_BYTE, A.image[y]);
										A.__webglInit = !0
									}
									Z(c.TEXTURE_CUBE_MAP, A, A.image[0]);
									c.bindTexture(c.TEXTURE_CUBE_MAP, null);
									A.needsUpdate = !1
								}
								c.activeTexture(c.TEXTURE0 + j);
								c.bindTexture(c.TEXTURE_CUBE_MAP,
									A.image.__webglTextureCube)
							}
						} else K(A, j)
				}
			}
		c.uniformMatrix4fv(x.modelViewMatrix, !1, m._modelViewMatrixArray);
		c.uniformMatrix3fv(x.normalMatrix, !1, m._normalMatrixArray);
		(k instanceof THREE.MeshShaderMaterial || k instanceof THREE.MeshPhongMaterial || k.envMap) && c.uniform3f(x.cameraPosition, f.position.x, f.position.y, f.position.z);
		(k instanceof THREE.MeshShaderMaterial || k.envMap || k.skinning) && c.uniformMatrix4fv(x.objectMatrix, !1, m._objectMatrixArray);
		(k instanceof THREE.MeshPhongMaterial || k instanceof THREE.MeshLambertMaterial ||
			k instanceof THREE.MeshShaderMaterial || k.skinning) && c.uniformMatrix4fv(x.viewMatrix, !1, Xa);
		if(k instanceof THREE.ShadowVolumeDynamicMaterial) {
			f = u.directionalLightDirection.value;
			f[0] = -s[1].position.x;
			f[1] = -s[1].position.y;
			f[2] = -s[1].position.z;
			c.uniform3fv(x.directionalLightDirection, f);
			c.uniformMatrix4fv(x.objectMatrix, !1, m._objectMatrixArray);
			c.uniformMatrix4fv(x.viewMatrix, !1, Xa)
		}
		if(k.skinning) {
			c.uniformMatrix4fv(x.cameraInverseMatrix, !1, Xa);
			c.uniformMatrix4fv(x.boneGlobalMatrices, !1, m.boneMatrices)
		}
		return w
	}

	function g(f, s, j, k, m, w) {
		if(k.opacity != 0) {
			var x;
			f = e(f, s, j, k, w).attributes;
			if(k.morphTargets) {
				s = k.program.attributes;
				w.morphTargetBase !== -1 ? c.bindBuffer(c.ARRAY_BUFFER, m.__webglMorphTargetsBuffers[w.morphTargetBase]) : c.bindBuffer(c.ARRAY_BUFFER, m.__webglVertexBuffer);
				c.vertexAttribPointer(s.position, 3, c.FLOAT, !1, 0, 0);
				if(w.morphTargetForcedOrder.length) {
					j = 0;
					for(var u = w.morphTargetForcedOrder, A = w.morphTargetInfluences; j < k.numSupportedMorphTargets && j < u.length;) {
						c.bindBuffer(c.ARRAY_BUFFER, m.__webglMorphTargetsBuffers[u[j]]);
						c.vertexAttribPointer(s["morphTarget" + j], 3, c.FLOAT, !1, 0, 0);
						w.__webglMorphTargetInfluences[j] = A[u[j]];
						j++
					}
				} else {
					u = [];
					var t = -1,
						y = 0;
					A = w.morphTargetInfluences;
					var z, D = A.length;
					j = 0;
					for(w.morphTargetBase !== -1 && (u[w.morphTargetBase] = !0); j < k.numSupportedMorphTargets;) {
						for(z = 0; z < D; z++)
							if(!u[z] && A[z] > t) {
								y = z;
								t = A[y]
							}
						c.bindBuffer(c.ARRAY_BUFFER, m.__webglMorphTargetsBuffers[y]);
						c.vertexAttribPointer(s["morphTarget" + j], 3, c.FLOAT, !1, 0, 0);
						w.__webglMorphTargetInfluences[j] = t;
						u[y] = 1;
						t = -1;
						j++
					}
				}
				c.uniform1fv(k.program.uniforms.morphTargetInfluences,
					w.__webglMorphTargetInfluences)
			} else {
				c.bindBuffer(c.ARRAY_BUFFER, m.__webglVertexBuffer);
				c.vertexAttribPointer(f.position, 3, c.FLOAT, !1, 0, 0)
			}
			if(m.__webglCustomAttributes)
				for(x in m.__webglCustomAttributes)
					if(f[x] >= 0) {
						s = m.__webglCustomAttributes[x];
						c.bindBuffer(c.ARRAY_BUFFER, s.buffer);
						c.vertexAttribPointer(f[x], s.size, c.FLOAT, !1, 0, 0)
					}
			if(f.color >= 0) {
				c.bindBuffer(c.ARRAY_BUFFER, m.__webglColorBuffer);
				c.vertexAttribPointer(f.color, 3, c.FLOAT, !1, 0, 0)
			}
			if(f.normal >= 0) {
				c.bindBuffer(c.ARRAY_BUFFER, m.__webglNormalBuffer);
				c.vertexAttribPointer(f.normal, 3, c.FLOAT, !1, 0, 0)
			}
			if(f.tangent >= 0) {
				c.bindBuffer(c.ARRAY_BUFFER, m.__webglTangentBuffer);
				c.vertexAttribPointer(f.tangent, 4, c.FLOAT, !1, 0, 0)
			}
			if(f.uv >= 0)
				if(m.__webglUVBuffer) {
					c.bindBuffer(c.ARRAY_BUFFER, m.__webglUVBuffer);
					c.vertexAttribPointer(f.uv, 2, c.FLOAT, !1, 0, 0);
					c.enableVertexAttribArray(f.uv)
				} else c.disableVertexAttribArray(f.uv);
			if(f.uv2 >= 0)
				if(m.__webglUV2Buffer) {
					c.bindBuffer(c.ARRAY_BUFFER, m.__webglUV2Buffer);
					c.vertexAttribPointer(f.uv2, 2, c.FLOAT, !1, 0, 0);
					c.enableVertexAttribArray(f.uv2)
				} else c.disableVertexAttribArray(f.uv2);
			if(k.skinning && f.skinVertexA >= 0 && f.skinVertexB >= 0 && f.skinIndex >= 0 && f.skinWeight >= 0) {
				c.bindBuffer(c.ARRAY_BUFFER, m.__webglSkinVertexABuffer);
				c.vertexAttribPointer(f.skinVertexA, 4, c.FLOAT, !1, 0, 0);
				c.bindBuffer(c.ARRAY_BUFFER, m.__webglSkinVertexBBuffer);
				c.vertexAttribPointer(f.skinVertexB, 4, c.FLOAT, !1, 0, 0);
				c.bindBuffer(c.ARRAY_BUFFER, m.__webglSkinIndicesBuffer);
				c.vertexAttribPointer(f.skinIndex, 4, c.FLOAT, !1, 0, 0);
				c.bindBuffer(c.ARRAY_BUFFER, m.__webglSkinWeightsBuffer);
				c.vertexAttribPointer(f.skinWeight,
					4, c.FLOAT, !1, 0, 0)
			}
			if(w instanceof THREE.Mesh)
				if(k.wireframe) {
					c.lineWidth(k.wireframeLinewidth);
					c.bindBuffer(c.ELEMENT_ARRAY_BUFFER, m.__webglLineBuffer);
					c.drawElements(c.LINES, m.__webglLineCount, c.UNSIGNED_SHORT, 0)
				} else {
					c.bindBuffer(c.ELEMENT_ARRAY_BUFFER, m.__webglFaceBuffer);
					c.drawElements(c.TRIANGLES, m.__webglFaceCount, c.UNSIGNED_SHORT, 0)
				}
			else if(w instanceof THREE.Line) {
				w = w.type == THREE.LineStrip ? c.LINE_STRIP : c.LINES;
				c.lineWidth(k.linewidth);
				c.drawArrays(w, 0, m.__webglLineCount)
			} else if(w instanceof THREE.ParticleSystem) c.drawArrays(c.POINTS, 0, m.__webglParticleCount);
			else w instanceof THREE.Ribbon && c.drawArrays(c.TRIANGLE_STRIP, 0, m.__webglVertexCount)
		}
	}

	function h(f, s, j) {
		if(!f.__webglVertexBuffer) f.__webglVertexBuffer = c.createBuffer();
		if(!f.__webglNormalBuffer) f.__webglNormalBuffer = c.createBuffer();
		if(f.hasPos) {
			c.bindBuffer(c.ARRAY_BUFFER, f.__webglVertexBuffer);
			c.bufferData(c.ARRAY_BUFFER, f.positionArray, c.DYNAMIC_DRAW);
			c.enableVertexAttribArray(s.attributes.position);
			c.vertexAttribPointer(s.attributes.position,
				3, c.FLOAT, !1, 0, 0)
		}
		if(f.hasNormal) {
			c.bindBuffer(c.ARRAY_BUFFER, f.__webglNormalBuffer);
			if(j == THREE.FlatShading) {
				var k, m, w, x, u, A, t, y, z, D, B = f.count * 3;
				for(D = 0; D < B; D += 9) {
					j = f.normalArray;
					k = j[D];
					m = j[D + 1];
					w = j[D + 2];
					x = j[D + 3];
					A = j[D + 4];
					y = j[D + 5];
					u = j[D + 6];
					t = j[D + 7];
					z = j[D + 8];
					k = (k + x + u) / 3;
					m = (m + A + t) / 3;
					w = (w + y + z) / 3;
					j[D] = k;
					j[D + 1] = m;
					j[D + 2] = w;
					j[D + 3] = k;
					j[D + 4] = m;
					j[D + 5] = w;
					j[D + 6] = k;
					j[D + 7] = m;
					j[D + 8] = w
				}
			}
			c.bufferData(c.ARRAY_BUFFER, f.normalArray, c.DYNAMIC_DRAW);
			c.enableVertexAttribArray(s.attributes.normal);
			c.vertexAttribPointer(s.attributes.normal,
				3, c.FLOAT, !1, 0, 0)
		}
		c.drawArrays(c.TRIANGLES, 0, f.count);
		f.count = 0
	}

	function o(f) {
		if(ma != f.doubleSided) {
			f.doubleSided ? c.disable(c.CULL_FACE) : c.enable(c.CULL_FACE);
			ma = f.doubleSided
		}
		if(na != f.flipSided) {
			f.flipSided ? c.frontFace(c.CW) : c.frontFace(c.CCW);
			na = f.flipSided
		}
	}

	function n(f) {
		if(Y != f) {
			f ? c.enable(c.DEPTH_TEST) : c.disable(c.DEPTH_TEST);
			Y = f
		}
	}

	function p(f) {
		$[0].set(f.n41 - f.n11, f.n42 - f.n12, f.n43 - f.n13, f.n44 - f.n14);
		$[1].set(f.n41 + f.n11, f.n42 + f.n12, f.n43 + f.n13, f.n44 + f.n14);
		$[2].set(f.n41 + f.n21, f.n42 + f.n22,
			f.n43 + f.n23, f.n44 + f.n24);
		$[3].set(f.n41 - f.n21, f.n42 - f.n22, f.n43 - f.n23, f.n44 - f.n24);
		$[4].set(f.n41 - f.n31, f.n42 - f.n32, f.n43 - f.n33, f.n44 - f.n34);
		$[5].set(f.n41 + f.n31, f.n42 + f.n32, f.n43 + f.n33, f.n44 + f.n34);
		var s;
		for(f = 0; f < 6; f++) {
			s = $[f];
			s.divideScalar(Math.sqrt(s.x * s.x + s.y * s.y + s.z * s.z))
		}
	}

	function q(f) {
		for(var s = f.matrixWorld, j = -f.geometry.boundingSphere.radius * Math.max(f.scale.x, Math.max(f.scale.y, f.scale.z)), k = 0; k < 6; k++) {
			f = $[k].x * s.n14 + $[k].y * s.n24 + $[k].z * s.n34 + $[k].w;
			if(f <= j) return !1
		}
		return !0
	}

	function v(f,
		s) {
		f.list[f.count] = s;
		f.count += 1
	}

	function E(f) {
		var s, j, k = f.object,
			m = f.opaque,
			w = f.transparent;
		w.count = 0;
		f = m.count = 0;
		for(s = k.materials.length; f < s; f++) {
			j = k.materials[f];
			j.transparent ? v(w, j) : v(m, j)
		}
	}

	function F(f) {
		var s, j, k, m, w = f.object,
			x = f.buffer,
			u = f.opaque,
			A = f.transparent;
		A.count = 0;
		f = u.count = 0;
		for(k = w.materials.length; f < k; f++) {
			s = w.materials[f];
			if(s instanceof THREE.MeshFaceMaterial) {
				s = 0;
				for(j = x.materials.length; s < j; s++)(m = x.materials[s]) && (m.transparent ? v(A, m) : v(u, m))
			} else(m = s) && (m.transparent ? v(A, m) :
				v(u, m))
		}
	}

	function H(f, s) {
		return s.z - f.z
	}

	function I(f) {
		c.enable(c.POLYGON_OFFSET_FILL);
		c.polygonOffset(0.1, 1);
		c.enable(c.STENCIL_TEST);
		c.enable(c.DEPTH_TEST);
		c.depthMask(!1);
		c.colorMask(!1, !1, !1, !1);
		c.stencilFunc(c.ALWAYS, 1, 255);
		c.stencilOpSeparate(c.BACK, c.KEEP, c.INCR, c.KEEP);
		c.stencilOpSeparate(c.FRONT, c.KEEP, c.DECR, c.KEEP);
		var s, j = f.lights.length,
			k, m = f.lights,
			w = [],
			x, u, A, t, y, z = f.__webglShadowVolumes.length;
		for(s = 0; s < j; s++) {
			k = f.lights[s];
			if(k instanceof THREE.DirectionalLight) {
				w[0] = -k.position.x;
				w[1] = -k.position.y;
				w[2] = -k.position.z;
				for(y = 0; y < z; y++) {
					k = f.__webglShadowVolumes[y].object;
					x = f.__webglShadowVolumes[y].buffer;
					u = k.materials[0];
					u.program || aa.initMaterial(u, m, undefined, k);
					u = u.program;
					A = u.uniforms;
					t = u.attributes;
					if(ra !== u) {
						c.useProgram(u);
						ra = u;
						c.uniformMatrix4fv(A.projectionMatrix, !1, Ta);
						c.uniformMatrix4fv(A.viewMatrix, !1, Xa);
						c.uniform3fv(A.directionalLightDirection, w)
					}
					k.matrixWorld.flattenToArray(k._objectMatrixArray);
					c.uniformMatrix4fv(A.objectMatrix, !1, k._objectMatrixArray);
					c.bindBuffer(c.ARRAY_BUFFER,
						x.__webglVertexBuffer);
					c.vertexAttribPointer(t.position, 3, c.FLOAT, !1, 0, 0);
					c.bindBuffer(c.ARRAY_BUFFER, x.__webglNormalBuffer);
					c.vertexAttribPointer(t.normal, 3, c.FLOAT, !1, 0, 0);
					c.bindBuffer(c.ELEMENT_ARRAY_BUFFER, x.__webglFaceBuffer);
					c.cullFace(c.FRONT);
					c.drawElements(c.TRIANGLES, x.__webglFaceCount, c.UNSIGNED_SHORT, 0);
					c.cullFace(c.BACK);
					c.drawElements(c.TRIANGLES, x.__webglFaceCount, c.UNSIGNED_SHORT, 0)
				}
			}
		}
		c.disable(c.POLYGON_OFFSET_FILL);
		c.colorMask(!0, !0, !0, !0);
		c.stencilFunc(c.NOTEQUAL, 0, 255);
		c.stencilOp(c.KEEP,
			c.KEEP, c.KEEP);
		c.disable(c.DEPTH_TEST);
		ga = "";
		ra = R.program;
		c.useProgram(R.program);
		c.uniformMatrix4fv(R.projectionLocation, !1, Ta);
		c.uniform1f(R.darknessLocation, R.darkness);
		c.bindBuffer(c.ARRAY_BUFFER, R.vertexBuffer);
		c.vertexAttribPointer(R.vertexLocation, 3, c.FLOAT, !1, 0, 0);
		c.enableVertexAttribArray(R.vertexLocation);
		c.blendFunc(c.ONE, c.ONE_MINUS_SRC_ALPHA);
		c.blendEquation(c.FUNC_ADD);
		c.bindBuffer(c.ELEMENT_ARRAY_BUFFER, R.elementBuffer);
		c.drawElements(c.TRIANGLES, 6, c.UNSIGNED_SHORT, 0);
		c.disable(c.STENCIL_TEST);
		c.enable(c.DEPTH_TEST);
		c.depthMask(ta)
	}

	function M(f, s) {
		var j, k, m;
		j = _sprite.attributes;
		var w = _sprite.uniforms,
			x = za / ya,
			u, A = [],
			t = ya * 0.5,
			y = za * 0.5,
			z = !0;
		c.useProgram(_sprite.program);
		ra = _sprite.program;
		ga = "";
		if(!ob) {
			c.enableVertexAttribArray(_sprite.attributes.position);
			c.enableVertexAttribArray(_sprite.attributes.uv);
			ob = !0
		}
		c.disable(c.CULL_FACE);
		c.enable(c.BLEND);
		c.depthMask(!0);
		c.bindBuffer(c.ARRAY_BUFFER, _sprite.vertexBuffer);
		c.vertexAttribPointer(j.position, 2, c.FLOAT, !1, 16, 0);
		c.vertexAttribPointer(j.uv,
			2, c.FLOAT, !1, 16, 8);
		c.bindBuffer(c.ELEMENT_ARRAY_BUFFER, _sprite.elementBuffer);
		c.uniformMatrix4fv(w.projectionMatrix, !1, Ta);
		c.activeTexture(c.TEXTURE0);
		c.uniform1i(w.map, 0);
		j = 0;
		for(k = f.__webglSprites.length; j < k; j++) {
			m = f.__webglSprites[j];
			if(m.useScreenCoordinates) m.z = -m.position.z;
			else {
				m._modelViewMatrix.multiplyToArray(s.matrixWorldInverse, m.matrixWorld, m._modelViewMatrixArray);
				m.z = -m._modelViewMatrix.n34
			}
		}
		f.__webglSprites.sort(H);
		j = 0;
		for(k = f.__webglSprites.length; j < k; j++) {
			m = f.__webglSprites[j];
			if(m.material ===
				undefined && m.map && m.map.image && m.map.image.width) {
				if(m.useScreenCoordinates) {
					c.uniform1i(w.useScreenCoordinates, 1);
					c.uniform3f(w.screenPosition, (m.position.x - t) / t, (y - m.position.y) / y, Math.max(0, Math.min(1, m.position.z)))
				} else {
					c.uniform1i(w.useScreenCoordinates, 0);
					c.uniform1i(w.affectedByDistance, m.affectedByDistance ? 1 : 0);
					c.uniformMatrix4fv(w.modelViewMatrix, !1, m._modelViewMatrixArray)
				}
				u = m.map.image.width / (m.affectedByDistance ? 1 : za);
				A[0] = u * x * m.scale.x;
				A[1] = u * m.scale.y;
				c.uniform2f(w.uvScale, m.uvScale.x,
					m.uvScale.y);
				c.uniform2f(w.uvOffset, m.uvOffset.x, m.uvOffset.y);
				c.uniform2f(w.alignment, m.alignment.x, m.alignment.y);
				c.uniform1f(w.opacity, m.opacity);
				c.uniform1f(w.rotation, m.rotation);
				c.uniform2fv(w.scale, A);
				if(m.mergeWith3D && !z) {
					c.enable(c.DEPTH_TEST);
					z = !0
				} else if(!m.mergeWith3D && z) {
					c.disable(c.DEPTH_TEST);
					z = !1
				}
				oa(m.blending);
				K(m.map, 0);
				c.drawElements(c.TRIANGLES, 6, c.UNSIGNED_SHORT, 0)
			}
		}
		c.enable(c.CULL_FACE);
		c.enable(c.DEPTH_TEST);
		c.depthMask(ta)
	}

	function N(f, s) {
		var j, k, m = f.__webglLensFlares.length,
			w, x, u, A = new THREE.Vector3,
			t = za / ya,
			y = ya * 0.5,
			z = za * 0.5,
			D = 16 / za,
			B = [D * t, D],
			O = [1, 1, 0],
			W = [1, 1],
			P = J.uniforms;
		j = J.attributes;
		c.useProgram(J.program);
		ra = J.program;
		ga = "";
		if(!pb) {
			c.enableVertexAttribArray(J.attributes.vertex);
			c.enableVertexAttribArray(J.attributes.uv);
			pb = !0
		}
		c.uniform1i(P.occlusionMap, 0);
		c.uniform1i(P.map, 1);
		c.bindBuffer(c.ARRAY_BUFFER, J.vertexBuffer);
		c.vertexAttribPointer(j.vertex, 2, c.FLOAT, !1, 16, 0);
		c.vertexAttribPointer(j.uv, 2, c.FLOAT, !1, 16, 8);
		c.bindBuffer(c.ELEMENT_ARRAY_BUFFER, J.elementBuffer);
		c.disable(c.CULL_FACE);
		c.depthMask(!1);
		c.activeTexture(c.TEXTURE0);
		c.bindTexture(c.TEXTURE_2D, J.occlusionTexture);
		c.activeTexture(c.TEXTURE1);
		for(k = 0; k < m; k++) {
			j = f.__webglLensFlares[k].object;
			A.set(j.matrixWorld.n14, j.matrixWorld.n24, j.matrixWorld.n34);
			s.matrixWorldInverse.multiplyVector3(A);
			s.projectionMatrix.multiplyVector3(A);
			O[0] = A.x;
			O[1] = A.y;
			O[2] = A.z;
			W[0] = O[0] * y + y;
			W[1] = O[1] * z + z;
			if(J.hasVertexTexture || W[0] > 0 && W[0] < ya && W[1] > 0 && W[1] < za) {
				c.bindTexture(c.TEXTURE_2D, J.tempTexture);
				c.copyTexImage2D(c.TEXTURE_2D,
					0, c.RGB, W[0] - 8, W[1] - 8, 16, 16, 0);
				c.uniform1i(P.renderType, 0);
				c.uniform2fv(P.scale, B);
				c.uniform3fv(P.screenPosition, O);
				c.disable(c.BLEND);
				c.enable(c.DEPTH_TEST);
				c.drawElements(c.TRIANGLES, 6, c.UNSIGNED_SHORT, 0);
				c.bindTexture(c.TEXTURE_2D, J.occlusionTexture);
				c.copyTexImage2D(c.TEXTURE_2D, 0, c.RGBA, W[0] - 8, W[1] - 8, 16, 16, 0);
				c.uniform1i(P.renderType, 1);
				c.disable(c.DEPTH_TEST);
				c.bindTexture(c.TEXTURE_2D, J.tempTexture);
				c.drawElements(c.TRIANGLES, 6, c.UNSIGNED_SHORT, 0);
				j.positionScreen.x = O[0];
				j.positionScreen.y =
					O[1];
				j.positionScreen.z = O[2];
				j.customUpdateCallback ? j.customUpdateCallback(j) : j.updateLensFlares();
				c.uniform1i(P.renderType, 2);
				c.enable(c.BLEND);
				w = 0;
				for(x = j.lensFlares.length; w < x; w++) {
					u = j.lensFlares[w];
					if(u.opacity > 0.0010 && u.scale > 0.0010) {
						O[0] = u.x;
						O[1] = u.y;
						O[2] = u.z;
						D = u.size * u.scale / za;
						B[0] = D * t;
						B[1] = D;
						c.uniform3fv(P.screenPosition, O);
						c.uniform2fv(P.scale, B);
						c.uniform1f(P.rotation, u.rotation);
						c.uniform1f(P.opacity, u.opacity);
						oa(u.blending);
						K(u.texture, 1);
						c.drawElements(c.TRIANGLES, 6, c.UNSIGNED_SHORT,
							0)
					}
				}
			}
		}
		c.enable(c.CULL_FACE);
		c.enable(c.DEPTH_TEST);
		c.depthMask(ta)
	}

	function V(f, s) {
		f._modelViewMatrix.multiplyToArray(s.matrixWorldInverse, f.matrixWorld, f._modelViewMatrixArray);
		THREE.Matrix4.makeInvert3x3(f._modelViewMatrix).transposeIntoArray(f._normalMatrixArray)
	}

	function L(f) {
		var s, j, k, m, w;
		if(f instanceof THREE.Mesh) {
			j = f.geometry;
			for(s in j.geometryGroups) {
				k = j.geometryGroups[s];
				w = !1;
				for(m in k.__webglCustomAttributes)
					if(k.__webglCustomAttributes[m].needsUpdate) {
						w = !0;
						break
					}
				if(j.__dirtyVertices ||
					j.__dirtyMorphTargets || j.__dirtyElements || j.__dirtyUvs || j.__dirtyNormals || j.__dirtyColors || j.__dirtyTangents || w) {
					w = c.DYNAMIC_DRAW;
					var x = void 0,
						u = void 0,
						A = void 0,
						t = void 0;
					A = void 0;
					var y = void 0,
						z = void 0,
						D = void 0,
						B = void 0,
						O = void 0,
						W = void 0,
						P = void 0,
						X = void 0,
						Ga = void 0,
						T = void 0,
						Q = void 0,
						U = void 0,
						ua = void 0;
					z = void 0;
					D = void 0;
					t = void 0;
					B = void 0;
					t = void 0;
					var r = void 0,
						G = void 0;
					z = void 0;
					r = void 0;
					G = void 0;
					var i = void 0,
						Ka = void 0;
					r = void 0;
					G = void 0;
					i = void 0;
					Ka = void 0;
					r = void 0;
					G = void 0;
					i = void 0;
					Ka = void 0;
					r = void 0;
					G = void 0;
					i = void 0;
					t = void 0;
					B = void 0;
					y = void 0;
					A = void 0;
					A = void 0;
					r = void 0;
					G = void 0;
					i = void 0;
					var Va = void 0,
						va = 0,
						Aa = 0,
						Za = 0,
						$a = 0,
						Ja = 0,
						La = 0,
						ea = 0,
						Ma = 0,
						xa = 0,
						C = 0,
						Ba = 0;
					G = r = 0;
					var Ca = k.__vertexArray,
						fb = k.__uvArray,
						gb = k.__uv2Array,
						Qa = k.__normalArray,
						ha = k.__tangentArray,
						Da = k.__colorArray,
						ia = k.__skinVertexAArray,
						ja = k.__skinVertexBArray,
						ka = k.__skinIndexArray,
						la = k.__skinWeightArray,
						hb = k.__morphTargetsArrays,
						Ra = k.__webglCustomAttributes;
					i = void 0;
					var Na = k.__faceArray,
						Oa = k.__lineArray,
						qb = k.__needsSmoothNormals;
					W = k.__vertexColorType;
					O = k.__uvType;
					P = k.__normalType;
					var Ha = f.geometry,
						ib = Ha.__dirtyVertices,
						jb = Ha.__dirtyElements,
						eb = Ha.__dirtyUvs,
						kb = Ha.__dirtyNormals,
						lb = Ha.__dirtyTangents,
						mb = Ha.__dirtyColors,
						nb = Ha.__dirtyMorphTargets,
						ab = Ha.vertices,
						rb = k.faces,
						ub = Ha.faces,
						sb = Ha.faceVertexUvs[0],
						tb = Ha.faceVertexUvs[1],
						bb = Ha.skinVerticesA,
						cb = Ha.skinVerticesB,
						db = Ha.skinIndices,
						Wa = Ha.skinWeights,
						Ya = f instanceof THREE.ShadowVolume ? Ha.edgeFaces : undefined;
					morphTargets = Ha.morphTargets;
					if(Ra)
						for(Va in Ra) {
							Ra[Va].offset = 0;
							Ra[Va].offsetSrc = 0
						}
					x =
						0;
					for(u = rb.length; x < u; x++) {
						A = rb[x];
						t = ub[A];
						sb && (X = sb[A]);
						tb && (Ga = tb[A]);
						A = t.vertexNormals;
						y = t.normal;
						z = t.vertexColors;
						D = t.color;
						B = t.vertexTangents;
						if(t instanceof THREE.Face3) {
							if(ib) {
								T = ab[t.a].position;
								Q = ab[t.b].position;
								U = ab[t.c].position;
								Ca[Aa] = T.x;
								Ca[Aa + 1] = T.y;
								Ca[Aa + 2] = T.z;
								Ca[Aa + 3] = Q.x;
								Ca[Aa + 4] = Q.y;
								Ca[Aa + 5] = Q.z;
								Ca[Aa + 6] = U.x;
								Ca[Aa + 7] = U.y;
								Ca[Aa + 8] = U.z;
								Aa += 9
							}
							if(Ra)
								for(Va in Ra) {
									i = Ra[Va];
									if(i.needsUpdate) {
										r = i.offset;
										G = i.offsetSrc;
										if(i.size === 1) {
											if(i.boundTo === undefined || i.boundTo === "vertices") {
												i.array[r +
													0] = i.value[t.a];
												i.array[r + 1] = i.value[t.b];
												i.array[r + 2] = i.value[t.c]
											} else if(i.boundTo === "faces") {
												i.array[r + 0] = i.value[G];
												i.array[r + 1] = i.value[G];
												i.array[r + 2] = i.value[G];
												i.offsetSrc++
											} else if(i.boundTo === "faceVertices") {
												i.array[r + 0] = i.value[G + 0];
												i.array[r + 1] = i.value[G + 1];
												i.array[r + 2] = i.value[G + 2];
												i.offsetSrc += 3
											}
											i.offset += 3
										} else {
											if(i.boundTo === undefined || i.boundTo === "vertices") {
												T = i.value[t.a];
												Q = i.value[t.b];
												U = i.value[t.c]
											} else if(i.boundTo === "faces") {
												T = i.value[G];
												Q = i.value[G];
												U = i.value[G];
												i.offsetSrc++
											} else if(i.boundTo ===
												"faceVertices") {
												T = i.value[G + 0];
												Q = i.value[G + 1];
												U = i.value[G + 2];
												i.offsetSrc += 3
											}
											if(i.size === 2) {
												i.array[r + 0] = T.x;
												i.array[r + 1] = T.y;
												i.array[r + 2] = Q.x;
												i.array[r + 3] = Q.y;
												i.array[r + 4] = U.x;
												i.array[r + 5] = U.y;
												i.offset += 6
											} else if(i.size === 3) {
												if(i.type === "c") {
													i.array[r + 0] = T.r;
													i.array[r + 1] = T.g;
													i.array[r + 2] = T.b;
													i.array[r + 3] = Q.r;
													i.array[r + 4] = Q.g;
													i.array[r + 5] = Q.b;
													i.array[r + 6] = U.r;
													i.array[r + 7] = U.g;
													i.array[r + 8] = U.b
												} else {
													i.array[r + 0] = T.x;
													i.array[r + 1] = T.y;
													i.array[r + 2] = T.z;
													i.array[r + 3] = Q.x;
													i.array[r + 4] = Q.y;
													i.array[r + 5] = Q.z;
													i.array[r + 6] = U.x;
													i.array[r + 7] = U.y;
													i.array[r + 8] = U.z
												}
												i.offset += 9
											} else {
												i.array[r + 0] = T.x;
												i.array[r + 1] = T.y;
												i.array[r + 2] = T.z;
												i.array[r + 3] = T.w;
												i.array[r + 4] = Q.x;
												i.array[r + 5] = Q.y;
												i.array[r + 6] = Q.z;
												i.array[r + 7] = Q.w;
												i.array[r + 8] = U.x;
												i.array[r + 9] = U.y;
												i.array[r + 10] = U.z;
												i.array[r + 11] = U.w;
												i.offset += 12
											}
										}
									}
								}
							if(nb) {
								r = 0;
								for(G = morphTargets.length; r < G; r++) {
									T = morphTargets[r].vertices[t.a].position;
									Q = morphTargets[r].vertices[t.b].position;
									U = morphTargets[r].vertices[t.c].position;
									i = hb[r];
									i[Ba + 0] = T.x;
									i[Ba + 1] = T.y;
									i[Ba + 2] = T.z;
									i[Ba + 3] = Q.x;
									i[Ba + 4] = Q.y;
									i[Ba + 5] = Q.z;
									i[Ba + 6] = U.x;
									i[Ba + 7] = U.y;
									i[Ba + 8] = U.z
								}
								Ba += 9
							}
							if(Wa.length) {
								r = Wa[t.a];
								G = Wa[t.b];
								i = Wa[t.c];
								la[C] = r.x;
								la[C + 1] = r.y;
								la[C + 2] = r.z;
								la[C + 3] = r.w;
								la[C + 4] = G.x;
								la[C + 5] = G.y;
								la[C + 6] = G.z;
								la[C + 7] = G.w;
								la[C + 8] = i.x;
								la[C + 9] = i.y;
								la[C + 10] = i.z;
								la[C + 11] = i.w;
								r = db[t.a];
								G = db[t.b];
								i = db[t.c];
								ka[C] = r.x;
								ka[C + 1] = r.y;
								ka[C + 2] = r.z;
								ka[C + 3] = r.w;
								ka[C + 4] = G.x;
								ka[C + 5] = G.y;
								ka[C + 6] = G.z;
								ka[C + 7] = G.w;
								ka[C + 8] = i.x;
								ka[C + 9] = i.y;
								ka[C + 10] = i.z;
								ka[C + 11] = i.w;
								r = bb[t.a];
								G = bb[t.b];
								i = bb[t.c];
								ia[C] = r.x;
								ia[C + 1] = r.y;
								ia[C + 2] = r.z;
								ia[C + 3] = 1;
								ia[C + 4] = G.x;
								ia[C + 5] = G.y;
								ia[C + 6] = G.z;
								ia[C + 7] = 1;
								ia[C + 8] = i.x;
								ia[C + 9] = i.y;
								ia[C + 10] = i.z;
								ia[C + 11] = 1;
								r = cb[t.a];
								G = cb[t.b];
								i = cb[t.c];
								ja[C] = r.x;
								ja[C + 1] = r.y;
								ja[C + 2] = r.z;
								ja[C + 3] = 1;
								ja[C + 4] = G.x;
								ja[C + 5] = G.y;
								ja[C + 6] = G.z;
								ja[C + 7] = 1;
								ja[C + 8] = i.x;
								ja[C + 9] = i.y;
								ja[C + 10] = i.z;
								ja[C + 11] = 1;
								C += 12
							}
							if(mb && W) {
								if(z.length == 3 && W == THREE.VertexColors) {
									t = z[0];
									r = z[1];
									G = z[2]
								} else G = r = t = D;
								Da[xa] = t.r;
								Da[xa + 1] = t.g;
								Da[xa + 2] = t.b;
								Da[xa + 3] = r.r;
								Da[xa + 4] = r.g;
								Da[xa + 5] = r.b;
								Da[xa + 6] = G.r;
								Da[xa + 7] = G.g;
								Da[xa + 8] = G.b;
								xa += 9
							}
							if(lb && Ha.hasTangents) {
								z =
									B[0];
								D = B[1];
								t = B[2];
								ha[ea] = z.x;
								ha[ea + 1] = z.y;
								ha[ea + 2] = z.z;
								ha[ea + 3] = z.w;
								ha[ea + 4] = D.x;
								ha[ea + 5] = D.y;
								ha[ea + 6] = D.z;
								ha[ea + 7] = D.w;
								ha[ea + 8] = t.x;
								ha[ea + 9] = t.y;
								ha[ea + 10] = t.z;
								ha[ea + 11] = t.w;
								ea += 12
							}
							if(kb && P)
								if(A.length == 3 && qb)
									for(B = 0; B < 3; B++) {
										y = A[B];
										Qa[La] = y.x;
										Qa[La + 1] = y.y;
										Qa[La + 2] = y.z;
										La += 3
									} else
										for(B = 0; B < 3; B++) {
											Qa[La] = y.x;
											Qa[La + 1] = y.y;
											Qa[La + 2] = y.z;
											La += 3
										}
							if(eb && X !== undefined && O)
								for(B = 0; B < 3; B++) {
									A = X[B];
									fb[Za] = A.u;
									fb[Za + 1] = A.v;
									Za += 2
								}
							if(eb && Ga !== undefined && O)
								for(B = 0; B < 3; B++) {
									A = Ga[B];
									gb[$a] = A.u;
									gb[$a + 1] = A.v;
									$a += 2
								}
							if(jb) {
								Na[Ja] =
									va;
								Na[Ja + 1] = va + 1;
								Na[Ja + 2] = va + 2;
								Ja += 3;
								Oa[Ma] = va;
								Oa[Ma + 1] = va + 1;
								Oa[Ma + 2] = va;
								Oa[Ma + 3] = va + 2;
								Oa[Ma + 4] = va + 1;
								Oa[Ma + 5] = va + 2;
								Ma += 6;
								va += 3
							}
						} else if(t instanceof THREE.Face4) {
							if(ib) {
								T = ab[t.a].position;
								Q = ab[t.b].position;
								U = ab[t.c].position;
								ua = ab[t.d].position;
								Ca[Aa] = T.x;
								Ca[Aa + 1] = T.y;
								Ca[Aa + 2] = T.z;
								Ca[Aa + 3] = Q.x;
								Ca[Aa + 4] = Q.y;
								Ca[Aa + 5] = Q.z;
								Ca[Aa + 6] = U.x;
								Ca[Aa + 7] = U.y;
								Ca[Aa + 8] = U.z;
								Ca[Aa + 9] = ua.x;
								Ca[Aa + 10] = ua.y;
								Ca[Aa + 11] = ua.z;
								Aa += 12
							}
							if(Ra)
								for(Va in Ra) {
									i = Ra[Va];
									if(i.needsUpdate) {
										r = i.offset;
										G = i.offsetSrc;
										if(i.size === 1) {
											if(i.boundTo ===
												undefined || i.boundTo === "vertices") {
												i.array[r + 0] = i.value[t.a];
												i.array[r + 1] = i.value[t.b];
												i.array[r + 2] = i.value[t.c];
												i.array[r + 2] = i.value[t.d]
											} else if(i.boundTo === "faces") {
												i.array[r + 0] = i.value[G];
												i.array[r + 1] = i.value[G];
												i.array[r + 2] = i.value[G];
												i.array[r + 2] = i.value[G];
												i.offsetSrc++
											} else if(i.boundTo === "faceVertices") {
												i.array[r + 0] = i.value[G + 0];
												i.array[r + 1] = i.value[G + 1];
												i.array[r + 2] = i.value[G + 2];
												i.array[r + 2] = i.value[G + 3];
												i.offsetSrc += 4
											}
											i.offset += 4
										} else {
											if(i.boundTo === undefined || i.boundTo === "vertices") {
												T =
													i.value[t.a];
												Q = i.value[t.b];
												U = i.value[t.c];
												ua = i.value[t.d]
											} else if(i.boundTo === "faces") {
												T = i.value[G];
												Q = i.value[G];
												U = i.value[G];
												ua = i.value[G];
												i.offsetSrc++
											} else if(i.boundTo === "faceVertices") {
												T = i.value[G + 0];
												Q = i.value[G + 1];
												U = i.value[G + 2];
												ua = i.value[G + 3];
												i.offsetSrc += 4
											}
											if(i.size === 2) {
												i.array[r + 0] = T.x;
												i.array[r + 1] = T.y;
												i.array[r + 2] = Q.x;
												i.array[r + 3] = Q.y;
												i.array[r + 4] = U.x;
												i.array[r + 5] = U.y;
												i.array[r + 6] = ua.x;
												i.array[r + 7] = ua.y;
												i.offset += 8
											} else if(i.size === 3) {
												if(i.type === "c") {
													i.array[r + 0] = T.r;
													i.array[r + 1] = T.g;
													i.array[r + 2] = T.b;
													i.array[r + 3] = Q.r;
													i.array[r + 4] = Q.g;
													i.array[r + 5] = Q.b;
													i.array[r + 6] = U.r;
													i.array[r + 7] = U.g;
													i.array[r + 8] = U.b;
													i.array[r + 9] = ua.r;
													i.array[r + 10] = ua.g;
													i.array[r + 11] = ua.b
												} else {
													i.array[r + 0] = T.x;
													i.array[r + 1] = T.y;
													i.array[r + 2] = T.z;
													i.array[r + 3] = Q.x;
													i.array[r + 4] = Q.y;
													i.array[r + 5] = Q.z;
													i.array[r + 6] = U.x;
													i.array[r + 7] = U.y;
													i.array[r + 8] = U.z;
													i.array[r + 9] = ua.x;
													i.array[r + 10] = ua.y;
													i.array[r + 11] = ua.z
												}
												i.offset += 12
											} else {
												i.array[r + 0] = T.x;
												i.array[r + 1] = T.y;
												i.array[r + 2] = T.z;
												i.array[r + 3] = T.w;
												i.array[r + 4] = Q.x;
												i.array[r +
													5] = Q.y;
												i.array[r + 6] = Q.z;
												i.array[r + 7] = Q.w;
												i.array[r + 8] = U.x;
												i.array[r + 9] = U.y;
												i.array[r + 10] = U.z;
												i.array[r + 11] = U.w;
												i.array[r + 12] = ua.x;
												i.array[r + 13] = ua.y;
												i.array[r + 14] = ua.z;
												i.array[r + 15] = ua.w;
												i.offset += 16
											}
										}
									}
								}
							if(nb) {
								r = 0;
								for(G = morphTargets.length; r < G; r++) {
									T = morphTargets[r].vertices[t.a].position;
									Q = morphTargets[r].vertices[t.b].position;
									U = morphTargets[r].vertices[t.c].position;
									ua = morphTargets[r].vertices[t.d].position;
									i = hb[r];
									i[Ba + 0] = T.x;
									i[Ba + 1] = T.y;
									i[Ba + 2] = T.z;
									i[Ba + 3] = Q.x;
									i[Ba + 4] = Q.y;
									i[Ba + 5] = Q.z;
									i[Ba + 6] =
										U.x;
									i[Ba + 7] = U.y;
									i[Ba + 8] = U.z;
									i[Ba + 9] = ua.x;
									i[Ba + 10] = ua.y;
									i[Ba + 11] = ua.z
								}
								Ba += 12
							}
							if(Wa.length) {
								r = Wa[t.a];
								G = Wa[t.b];
								i = Wa[t.c];
								Ka = Wa[t.d];
								la[C] = r.x;
								la[C + 1] = r.y;
								la[C + 2] = r.z;
								la[C + 3] = r.w;
								la[C + 4] = G.x;
								la[C + 5] = G.y;
								la[C + 6] = G.z;
								la[C + 7] = G.w;
								la[C + 8] = i.x;
								la[C + 9] = i.y;
								la[C + 10] = i.z;
								la[C + 11] = i.w;
								la[C + 12] = Ka.x;
								la[C + 13] = Ka.y;
								la[C + 14] = Ka.z;
								la[C + 15] = Ka.w;
								r = db[t.a];
								G = db[t.b];
								i = db[t.c];
								Ka = db[t.d];
								ka[C] = r.x;
								ka[C + 1] = r.y;
								ka[C + 2] = r.z;
								ka[C + 3] = r.w;
								ka[C + 4] = G.x;
								ka[C + 5] = G.y;
								ka[C + 6] = G.z;
								ka[C + 7] = G.w;
								ka[C + 8] = i.x;
								ka[C + 9] = i.y;
								ka[C + 10] = i.z;
								ka[C + 11] = i.w;
								ka[C + 12] = Ka.x;
								ka[C + 13] = Ka.y;
								ka[C + 14] = Ka.z;
								ka[C + 15] = Ka.w;
								r = bb[t.a];
								G = bb[t.b];
								i = bb[t.c];
								Ka = bb[t.d];
								ia[C] = r.x;
								ia[C + 1] = r.y;
								ia[C + 2] = r.z;
								ia[C + 3] = 1;
								ia[C + 4] = G.x;
								ia[C + 5] = G.y;
								ia[C + 6] = G.z;
								ia[C + 7] = 1;
								ia[C + 8] = i.x;
								ia[C + 9] = i.y;
								ia[C + 10] = i.z;
								ia[C + 11] = 1;
								ia[C + 12] = Ka.x;
								ia[C + 13] = Ka.y;
								ia[C + 14] = Ka.z;
								ia[C + 15] = 1;
								r = cb[t.a];
								G = cb[t.b];
								i = cb[t.c];
								t = cb[t.d];
								ja[C] = r.x;
								ja[C + 1] = r.y;
								ja[C + 2] = r.z;
								ja[C + 3] = 1;
								ja[C + 4] = G.x;
								ja[C + 5] = G.y;
								ja[C + 6] = G.z;
								ja[C + 7] = 1;
								ja[C + 8] = i.x;
								ja[C + 9] = i.y;
								ja[C + 10] = i.z;
								ja[C + 11] = 1;
								ja[C + 12] = t.x;
								ja[C + 13] =
									t.y;
								ja[C + 14] = t.z;
								ja[C + 15] = 1;
								C += 16
							}
							if(mb && W) {
								if(z.length == 4 && W == THREE.VertexColors) {
									t = z[0];
									r = z[1];
									G = z[2];
									z = z[3]
								} else z = G = r = t = D;
								Da[xa] = t.r;
								Da[xa + 1] = t.g;
								Da[xa + 2] = t.b;
								Da[xa + 3] = r.r;
								Da[xa + 4] = r.g;
								Da[xa + 5] = r.b;
								Da[xa + 6] = G.r;
								Da[xa + 7] = G.g;
								Da[xa + 8] = G.b;
								Da[xa + 9] = z.r;
								Da[xa + 10] = z.g;
								Da[xa + 11] = z.b;
								xa += 12
							}
							if(lb && Ha.hasTangents) {
								z = B[0];
								D = B[1];
								t = B[2];
								B = B[3];
								ha[ea] = z.x;
								ha[ea + 1] = z.y;
								ha[ea + 2] = z.z;
								ha[ea + 3] = z.w;
								ha[ea + 4] = D.x;
								ha[ea + 5] = D.y;
								ha[ea + 6] = D.z;
								ha[ea + 7] = D.w;
								ha[ea + 8] = t.x;
								ha[ea + 9] = t.y;
								ha[ea + 10] = t.z;
								ha[ea + 11] = t.w;
								ha[ea +
									12] = B.x;
								ha[ea + 13] = B.y;
								ha[ea + 14] = B.z;
								ha[ea + 15] = B.w;
								ea += 16
							}
							if(kb && P)
								if(A.length == 4 && qb)
									for(B = 0; B < 4; B++) {
										y = A[B];
										Qa[La] = y.x;
										Qa[La + 1] = y.y;
										Qa[La + 2] = y.z;
										La += 3
									} else
										for(B = 0; B < 4; B++) {
											Qa[La] = y.x;
											Qa[La + 1] = y.y;
											Qa[La + 2] = y.z;
											La += 3
										}
							if(eb && X !== undefined && O)
								for(B = 0; B < 4; B++) {
									A = X[B];
									fb[Za] = A.u;
									fb[Za + 1] = A.v;
									Za += 2
								}
							if(eb && Ga !== undefined && O)
								for(B = 0; B < 4; B++) {
									A = Ga[B];
									gb[$a] = A.u;
									gb[$a + 1] = A.v;
									$a += 2
								}
							if(jb) {
								Na[Ja] = va;
								Na[Ja + 1] = va + 1;
								Na[Ja + 2] = va + 3;
								Na[Ja + 3] = va + 1;
								Na[Ja + 4] = va + 2;
								Na[Ja + 5] = va + 3;
								Ja += 6;
								Oa[Ma] = va;
								Oa[Ma + 1] = va + 1;
								Oa[Ma + 2] =
									va;
								Oa[Ma + 3] = va + 3;
								Oa[Ma + 4] = va + 1;
								Oa[Ma + 5] = va + 2;
								Oa[Ma + 6] = va + 2;
								Oa[Ma + 7] = va + 3;
								Ma += 8;
								va += 4
							}
						}
					}
					if(Ya) {
						x = 0;
						for(u = Ya.length; x < u; x++) {
							Na[Ja] = Ya[x].a;
							Na[Ja + 1] = Ya[x].b;
							Na[Ja + 2] = Ya[x].c;
							Na[Ja + 3] = Ya[x].a;
							Na[Ja + 4] = Ya[x].c;
							Na[Ja + 5] = Ya[x].d;
							Ja += 6
						}
					}
					if(ib) {
						c.bindBuffer(c.ARRAY_BUFFER, k.__webglVertexBuffer);
						c.bufferData(c.ARRAY_BUFFER, Ca, w)
					}
					if(Ra)
						for(Va in Ra) {
							i = Ra[Va];
							if(i.needsUpdate) {
								c.bindBuffer(c.ARRAY_BUFFER, i.buffer);
								c.bufferData(c.ARRAY_BUFFER, i.array, w);
								i.needsUpdate = !1
							}
						}
					if(nb) {
						r = 0;
						for(G = morphTargets.length; r <
							G; r++) {
							c.bindBuffer(c.ARRAY_BUFFER, k.__webglMorphTargetsBuffers[r]);
							c.bufferData(c.ARRAY_BUFFER, hb[r], w)
						}
					}
					if(mb && xa > 0) {
						c.bindBuffer(c.ARRAY_BUFFER, k.__webglColorBuffer);
						c.bufferData(c.ARRAY_BUFFER, Da, w)
					}
					if(kb) {
						c.bindBuffer(c.ARRAY_BUFFER, k.__webglNormalBuffer);
						c.bufferData(c.ARRAY_BUFFER, Qa, w)
					}
					if(lb && Ha.hasTangents) {
						c.bindBuffer(c.ARRAY_BUFFER, k.__webglTangentBuffer);
						c.bufferData(c.ARRAY_BUFFER, ha, w)
					}
					if(eb && Za > 0) {
						c.bindBuffer(c.ARRAY_BUFFER, k.__webglUVBuffer);
						c.bufferData(c.ARRAY_BUFFER, fb, w)
					}
					if(eb &&
						$a > 0) {
						c.bindBuffer(c.ARRAY_BUFFER, k.__webglUV2Buffer);
						c.bufferData(c.ARRAY_BUFFER, gb, w)
					}
					if(jb) {
						c.bindBuffer(c.ELEMENT_ARRAY_BUFFER, k.__webglFaceBuffer);
						c.bufferData(c.ELEMENT_ARRAY_BUFFER, Na, w);
						c.bindBuffer(c.ELEMENT_ARRAY_BUFFER, k.__webglLineBuffer);
						c.bufferData(c.ELEMENT_ARRAY_BUFFER, Oa, w)
					}
					if(C > 0) {
						c.bindBuffer(c.ARRAY_BUFFER, k.__webglSkinVertexABuffer);
						c.bufferData(c.ARRAY_BUFFER, ia, w);
						c.bindBuffer(c.ARRAY_BUFFER, k.__webglSkinVertexBBuffer);
						c.bufferData(c.ARRAY_BUFFER, ja, w);
						c.bindBuffer(c.ARRAY_BUFFER,
							k.__webglSkinIndicesBuffer);
						c.bufferData(c.ARRAY_BUFFER, ka, w);
						c.bindBuffer(c.ARRAY_BUFFER, k.__webglSkinWeightsBuffer);
						c.bufferData(c.ARRAY_BUFFER, la, w)
					}
				}
			}
			j.__dirtyVertices = !1;
			j.__dirtyMorphTargets = !1;
			j.__dirtyElements = !1;
			j.__dirtyUvs = !1;
			j.__dirtyNormals = !1;
			j.__dirtyTangents = !1;
			j.__dirtyColors = !1
		} else if(f instanceof THREE.Ribbon) {
			j = f.geometry;
			if(j.__dirtyVertices || j.__dirtyColors) {
				f = j;
				s = c.DYNAMIC_DRAW;
				W = f.vertices;
				k = f.colors;
				P = W.length;
				w = k.length;
				X = f.__vertexArray;
				x = f.__colorArray;
				Ga = f.__dirtyColors;
				if(f.__dirtyVertices) {
					for(u = 0; u < P; u++) {
						O = W[u].position;
						m = u * 3;
						X[m] = O.x;
						X[m + 1] = O.y;
						X[m + 2] = O.z
					}
					c.bindBuffer(c.ARRAY_BUFFER, f.__webglVertexBuffer);
					c.bufferData(c.ARRAY_BUFFER, X, s)
				}
				if(Ga) {
					for(u = 0; u < w; u++) {
						color = k[u];
						m = u * 3;
						x[m] = color.r;
						x[m + 1] = color.g;
						x[m + 2] = color.b
					}
					c.bindBuffer(c.ARRAY_BUFFER, f.__webglColorBuffer);
					c.bufferData(c.ARRAY_BUFFER, x, s)
				}
			}
			j.__dirtyVertices = !1;
			j.__dirtyColors = !1
		} else if(f instanceof THREE.Line) {
			j = f.geometry;
			if(j.__dirtyVertices || j.__dirtyColors) {
				f = j;
				s = c.DYNAMIC_DRAW;
				W = f.vertices;
				k = f.colors;
				P = W.length;
				w = k.length;
				X = f.__vertexArray;
				x = f.__colorArray;
				Ga = f.__dirtyColors;
				if(f.__dirtyVertices) {
					for(u = 0; u < P; u++) {
						O = W[u].position;
						m = u * 3;
						X[m] = O.x;
						X[m + 1] = O.y;
						X[m + 2] = O.z
					}
					c.bindBuffer(c.ARRAY_BUFFER, f.__webglVertexBuffer);
					c.bufferData(c.ARRAY_BUFFER, X, s)
				}
				if(Ga) {
					for(u = 0; u < w; u++) {
						color = k[u];
						m = u * 3;
						x[m] = color.r;
						x[m + 1] = color.g;
						x[m + 2] = color.b
					}
					c.bindBuffer(c.ARRAY_BUFFER, f.__webglColorBuffer);
					c.bufferData(c.ARRAY_BUFFER, x, s)
				}
			}
			j.__dirtyVertices = !1;
			j.__dirtyColors = !1
		} else if(f instanceof THREE.ParticleSystem) {
			j =
				f.geometry;
			(j.__dirtyVertices || j.__dirtyColors || f.sortParticles) && d(j, c.DYNAMIC_DRAW, f);
			j.__dirtyVertices = !1;
			j.__dirtyColors = !1
		}
	}

	function sa(f) {
		function s(D) {
			var B = [];
			j = 0;
			for(k = D.length; j < k; j++) D[j] == undefined ? B.push("undefined") : B.push(D[j].id);
			return B.join("_")
		}
		var j, k, m, w, x, u, A, t, y = {},
			z = f.morphTargets !== undefined ? f.morphTargets.length : 0;
		f.geometryGroups = {};
		m = 0;
		for(w = f.faces.length; m < w; m++) {
			x = f.faces[m];
			u = x.materials;
			A = s(u);
			y[A] == undefined && (y[A] = {
				hash: A,
				counter: 0
			});
			t = y[A].hash + "_" + y[A].counter;
			f.geometryGroups[t] == undefined && (f.geometryGroups[t] = {
				faces: [],
				materials: u,
				vertices: 0,
				numMorphTargets: z
			});
			x = x instanceof THREE.Face3 ? 3 : 4;
			if(f.geometryGroups[t].vertices + x > 65535) {
				y[A].counter += 1;
				t = y[A].hash + "_" + y[A].counter;
				f.geometryGroups[t] == undefined && (f.geometryGroups[t] = {
					faces: [],
					materials: u,
					vertices: 0,
					numMorphTargets: z
				})
			}
			f.geometryGroups[t].faces.push(m);
			f.geometryGroups[t].vertices += x
		}
	}

	function da(f, s, j) {
		f.push({
			buffer: s,
			object: j,
			opaque: {
				list: [],
				count: 0
			},
			transparent: {
				list: [],
				count: 0
			}
		})
	}

	function oa(f) {
		if(f !=
			ga) {
			switch(f) {
				case THREE.AdditiveBlending:
					c.blendEquation(c.FUNC_ADD);
					c.blendFunc(c.SRC_ALPHA, c.ONE);
					break;
				case THREE.SubtractiveBlending:
					c.blendEquation(c.FUNC_ADD);
					c.blendFunc(c.ZERO, c.ONE_MINUS_SRC_COLOR);
					break;
				case THREE.MultiplyBlending:
					c.blendEquation(c.FUNC_ADD);
					c.blendFunc(c.ZERO, c.SRC_COLOR);
					break;
				default:
					c.blendEquationSeparate(c.FUNC_ADD, c.FUNC_ADD);
					c.blendFuncSeparate(c.SRC_ALPHA, c.ONE_MINUS_SRC_ALPHA, c.ONE, c.ONE_MINUS_SRC_ALPHA)
			}
			ga = f
		}
	}

	function Z(f, s, j) {
		if((j.width & j.width - 1) == 0 && (j.height &
				j.height - 1) == 0) {
			c.texParameteri(f, c.TEXTURE_WRAP_S, fa(s.wrapS));
			c.texParameteri(f, c.TEXTURE_WRAP_T, fa(s.wrapT));
			c.texParameteri(f, c.TEXTURE_MAG_FILTER, fa(s.magFilter));
			c.texParameteri(f, c.TEXTURE_MIN_FILTER, fa(s.minFilter));
			c.generateMipmap(f)
		} else {
			c.texParameteri(f, c.TEXTURE_WRAP_S, c.CLAMP_TO_EDGE);
			c.texParameteri(f, c.TEXTURE_WRAP_T, c.CLAMP_TO_EDGE);
			c.texParameteri(f, c.TEXTURE_MAG_FILTER, Ea(s.magFilter));
			c.texParameteri(f, c.TEXTURE_MIN_FILTER, Ea(s.minFilter))
		}
	}

	function K(f, s) {
		if(f.needsUpdate) {
			if(f.__webglInit) {
				c.bindTexture(c.TEXTURE_2D,
					f.__webglTexture);
				c.texSubImage2D(c.TEXTURE_2D, 0, 0, 0, c.RGBA, c.UNSIGNED_BYTE, f.image)
			} else {
				f.__webglTexture = c.createTexture();
				c.bindTexture(c.TEXTURE_2D, f.__webglTexture);
				c.texImage2D(c.TEXTURE_2D, 0, c.RGBA, c.RGBA, c.UNSIGNED_BYTE, f.image);
				f.__webglInit = !0
			}
			Z(c.TEXTURE_2D, f, f.image);
			c.bindTexture(c.TEXTURE_2D, null);
			f.needsUpdate = !1
		}
		c.activeTexture(c.TEXTURE0 + s);
		c.bindTexture(c.TEXTURE_2D, f.__webglTexture)
	}

	function Ia(f) {
		if(f && !f.__webglFramebuffer) {
			if(f.depthBuffer === undefined) f.depthBuffer = !0;
			if(f.stencilBuffer ===
				undefined) f.stencilBuffer = !0;
			f.__webglFramebuffer = c.createFramebuffer();
			f.__webglRenderbuffer = c.createRenderbuffer();
			f.__webglTexture = c.createTexture();
			c.bindTexture(c.TEXTURE_2D, f.__webglTexture);
			c.texParameteri(c.TEXTURE_2D, c.TEXTURE_WRAP_S, fa(f.wrapS));
			c.texParameteri(c.TEXTURE_2D, c.TEXTURE_WRAP_T, fa(f.wrapT));
			c.texParameteri(c.TEXTURE_2D, c.TEXTURE_MAG_FILTER, fa(f.magFilter));
			c.texParameteri(c.TEXTURE_2D, c.TEXTURE_MIN_FILTER, fa(f.minFilter));
			c.texImage2D(c.TEXTURE_2D, 0, fa(f.format), f.width, f.height,
				0, fa(f.format), fa(f.type), null);
			c.bindRenderbuffer(c.RENDERBUFFER, f.__webglRenderbuffer);
			c.bindFramebuffer(c.FRAMEBUFFER, f.__webglFramebuffer);
			c.framebufferTexture2D(c.FRAMEBUFFER, c.COLOR_ATTACHMENT0, c.TEXTURE_2D, f.__webglTexture, 0);
			if(f.depthBuffer && !f.stencilBuffer) {
				c.renderbufferStorage(c.RENDERBUFFER, c.DEPTH_COMPONENT16, f.width, f.height);
				c.framebufferRenderbuffer(c.FRAMEBUFFER, c.DEPTH_ATTACHMENT, c.RENDERBUFFER, f.__webglRenderbuffer)
			} else if(f.depthBuffer && f.stencilBuffer) {
				c.renderbufferStorage(c.RENDERBUFFER,
					c.DEPTH_STENCIL, f.width, f.height);
				c.framebufferRenderbuffer(c.FRAMEBUFFER, c.DEPTH_STENCIL_ATTACHMENT, c.RENDERBUFFER, f.__webglRenderbuffer)
			} else c.renderbufferStorage(c.RENDERBUFFER, c.RGBA4, f.width, f.height);
			c.bindTexture(c.TEXTURE_2D, null);
			c.bindRenderbuffer(c.RENDERBUFFER, null);
			c.bindFramebuffer(c.FRAMEBUFFER, null)
		}
		var s, j;
		if(f) {
			s = f.__webglFramebuffer;
			j = f.width;
			f = f.height
		} else {
			s = null;
			j = ya;
			f = za
		}
		if(s != Fa) {
			c.bindFramebuffer(c.FRAMEBUFFER, s);
			c.viewport(wa, qa, j, f);
			Fa = s
		}
	}

	function ca(f, s) {
		var j;
		if(f == "fragment") j =
			c.createShader(c.FRAGMENT_SHADER);
		else f == "vertex" && (j = c.createShader(c.VERTEX_SHADER));
		c.shaderSource(j, s);
		c.compileShader(j);
		if(!c.getShaderParameter(j, c.COMPILE_STATUS)) {
			console.error(c.getShaderInfoLog(j));
			console.error(s);
			return null
		}
		return j
	}

	function Ea(f) {
		switch(f) {
			case THREE.NearestFilter:
			case THREE.NearestMipMapNearestFilter:
			case THREE.NearestMipMapLinearFilter:
				return c.NEAREST;
			default:
				return c.LINEAR
		}
	}

	function fa(f) {
		switch(f) {
			case THREE.RepeatWrapping:
				return c.REPEAT;
			case THREE.ClampToEdgeWrapping:
				return c.CLAMP_TO_EDGE;
			case THREE.MirroredRepeatWrapping:
				return c.MIRRORED_REPEAT;
			case THREE.NearestFilter:
				return c.NEAREST;
			case THREE.NearestMipMapNearestFilter:
				return c.NEAREST_MIPMAP_NEAREST;
			case THREE.NearestMipMapLinearFilter:
				return c.NEAREST_MIPMAP_LINEAR;
			case THREE.LinearFilter:
				return c.LINEAR;
			case THREE.LinearMipMapNearestFilter:
				return c.LINEAR_MIPMAP_NEAREST;
			case THREE.LinearMipMapLinearFilter:
				return c.LINEAR_MIPMAP_LINEAR;
			case THREE.ByteType:
				return c.BYTE;
			case THREE.UnsignedByteType:
				return c.UNSIGNED_BYTE;
			case THREE.ShortType:
				return c.SHORT;
			case THREE.UnsignedShortType:
				return c.UNSIGNED_SHORT;
			case THREE.IntType:
				return c.INT;
			case THREE.UnsignedShortType:
				return c.UNSIGNED_INT;
			case THREE.FloatType:
				return c.FLOAT;
			case THREE.AlphaFormat:
				return c.ALPHA;
			case THREE.RGBFormat:
				return c.RGB;
			case THREE.RGBAFormat:
				return c.RGBA;
			case THREE.LuminanceFormat:
				return c.LUMINANCE;
			case THREE.LuminanceAlphaFormat:
				return c.LUMINANCE_ALPHA
		}
		return 0
	}
	var c, S = document.createElement("canvas"),
		pa = [],
		ra = null,
		Fa = null,
		ta = !0,
		aa = this,
		ma = null,
		na = null,
		ga = null,
		Y = null,
		wa =
		0,
		qa = 0,
		ya = 0,
		za = 0,
		$ = [new THREE.Vector4, new THREE.Vector4, new THREE.Vector4, new THREE.Vector4, new THREE.Vector4, new THREE.Vector4],
		Pa = new THREE.Matrix4,
		Ta = new Float32Array(16),
		Xa = new Float32Array(16),
		Ua = new THREE.Vector4,
		Sa = {
			ambient: [0, 0, 0],
			directional: {
				length: 0,
				colors: [],
				positions: []
			},
			point: {
				length: 0,
				colors: [],
				positions: [],
				distances: []
			}
		};
	b = b || {};
	stencil = b.stencil !== undefined ? b.stencil : !0;
	antialias = b.antialias !== undefined ? b.antialias : !1;
	clearColor = b.clearColor !== undefined ? new THREE.Color(b.clearColor) :
		new THREE.Color(0);
	clearAlpha = b.clearAlpha !== undefined ? b.clearAlpha : 0;
	this.maxMorphTargets = 8;
	this.domElement = S;
	this.autoClear = !0;
	this.sortObjects = !0;
	(function(f, s, j, k) {
		try {
			if(!(c = S.getContext("experimental-webgl", {
					antialias: f,
					stencil: k
				}))) throw "Error creating WebGL context.";
		} catch(m) {
			console.error(m)
		}
		console.log(navigator.userAgent + " | " + c.getParameter(c.VERSION) + " | " + c.getParameter(c.VENDOR) + " | " + c.getParameter(c.RENDERER) + " | " + c.getParameter(c.SHADING_LANGUAGE_VERSION));
		c.clearColor(0, 0, 0, 1);
		c.clearDepth(1);
		c.enable(c.DEPTH_TEST);
		c.depthFunc(c.LEQUAL);
		c.frontFace(c.CCW);
		c.cullFace(c.BACK);
		c.enable(c.CULL_FACE);
		c.enable(c.BLEND);
		c.blendEquation(c.FUNC_ADD);
		c.blendFunc(c.SRC_ALPHA, c.ONE_MINUS_SRC_ALPHA);
		c.clearColor(s.r, s.g, s.b, j)
	})(antialias, clearColor, clearAlpha, stencil);
	this.context = c;
	if(stencil) {
		var R = {};
		R.vertices = new Float32Array(12);
		R.faces = new Uint16Array(6);
		R.darkness = 0.5;
		R.vertices[0] = -20;
		R.vertices[1] = -20;
		R.vertices[2] = -1;
		R.vertices[3] = 20;
		R.vertices[4] = -20;
		R.vertices[5] = -1;
		R.vertices[6] =
			20;
		R.vertices[7] = 20;
		R.vertices[8] = -1;
		R.vertices[9] = -20;
		R.vertices[10] = 20;
		R.vertices[11] = -1;
		R.faces[0] = 0;
		R.faces[1] = 1;
		R.faces[2] = 2;
		R.faces[3] = 0;
		R.faces[4] = 2;
		R.faces[5] = 3;
		R.vertexBuffer = c.createBuffer();
		R.elementBuffer = c.createBuffer();
		c.bindBuffer(c.ARRAY_BUFFER, R.vertexBuffer);
		c.bufferData(c.ARRAY_BUFFER, R.vertices, c.STATIC_DRAW);
		c.bindBuffer(c.ELEMENT_ARRAY_BUFFER, R.elementBuffer);
		c.bufferData(c.ELEMENT_ARRAY_BUFFER, R.faces, c.STATIC_DRAW);
		R.program = c.createProgram();
		c.attachShader(R.program, ca("fragment",
			THREE.ShaderLib.shadowPost.fragmentShader));
		c.attachShader(R.program, ca("vertex", THREE.ShaderLib.shadowPost.vertexShader));
		c.linkProgram(R.program);
		R.vertexLocation = c.getAttribLocation(R.program, "position");
		R.projectionLocation = c.getUniformLocation(R.program, "projectionMatrix");
		R.darknessLocation = c.getUniformLocation(R.program, "darkness")
	}
	var J = {};
	J.vertices = new Float32Array(16);
	J.faces = new Uint16Array(6);
	b = 0;
	J.vertices[b++] = -1;
	J.vertices[b++] = -1;
	J.vertices[b++] = 0;
	J.vertices[b++] = 0;
	J.vertices[b++] =
		1;
	J.vertices[b++] = -1;
	J.vertices[b++] = 1;
	J.vertices[b++] = 0;
	J.vertices[b++] = 1;
	J.vertices[b++] = 1;
	J.vertices[b++] = 1;
	J.vertices[b++] = 1;
	J.vertices[b++] = -1;
	J.vertices[b++] = 1;
	J.vertices[b++] = 0;
	J.vertices[b++] = 1;
	b = 0;
	J.faces[b++] = 0;
	J.faces[b++] = 1;
	J.faces[b++] = 2;
	J.faces[b++] = 0;
	J.faces[b++] = 2;
	J.faces[b++] = 3;
	J.vertexBuffer = c.createBuffer();
	J.elementBuffer = c.createBuffer();
	J.tempTexture = c.createTexture();
	J.occlusionTexture = c.createTexture();
	c.bindBuffer(c.ARRAY_BUFFER, J.vertexBuffer);
	c.bufferData(c.ARRAY_BUFFER,
		J.vertices, c.STATIC_DRAW);
	c.bindBuffer(c.ELEMENT_ARRAY_BUFFER, J.elementBuffer);
	c.bufferData(c.ELEMENT_ARRAY_BUFFER, J.faces, c.STATIC_DRAW);
	c.bindTexture(c.TEXTURE_2D, J.tempTexture);
	c.texImage2D(c.TEXTURE_2D, 0, c.RGB, 16, 16, 0, c.RGB, c.UNSIGNED_BYTE, null);
	c.texParameteri(c.TEXTURE_2D, c.TEXTURE_WRAP_S, c.CLAMP_TO_EDGE);
	c.texParameteri(c.TEXTURE_2D, c.TEXTURE_WRAP_T, c.CLAMP_TO_EDGE);
	c.texParameteri(c.TEXTURE_2D, c.TEXTURE_MAG_FILTER, c.NEAREST);
	c.texParameteri(c.TEXTURE_2D, c.TEXTURE_MIN_FILTER, c.NEAREST);
	c.bindTexture(c.TEXTURE_2D,
		J.occlusionTexture);
	c.texImage2D(c.TEXTURE_2D, 0, c.RGBA, 16, 16, 0, c.RGBA, c.UNSIGNED_BYTE, null);
	c.texParameteri(c.TEXTURE_2D, c.TEXTURE_WRAP_S, c.CLAMP_TO_EDGE);
	c.texParameteri(c.TEXTURE_2D, c.TEXTURE_WRAP_T, c.CLAMP_TO_EDGE);
	c.texParameteri(c.TEXTURE_2D, c.TEXTURE_MAG_FILTER, c.NEAREST);
	c.texParameteri(c.TEXTURE_2D, c.TEXTURE_MIN_FILTER, c.NEAREST);
	if(c.getParameter(c.MAX_VERTEX_TEXTURE_IMAGE_UNITS) <= 0) {
		J.hasVertexTexture = !1;
		J.program = c.createProgram();
		c.attachShader(J.program, ca("fragment", THREE.ShaderLib.lensFlare.fragmentShader));
		c.attachShader(J.program, ca("vertex", THREE.ShaderLib.lensFlare.vertexShader))
	} else {
		J.hasVertexTexture = !0;
		J.program = c.createProgram();
		c.attachShader(J.program, ca("fragment", THREE.ShaderLib.lensFlareVertexTexture.fragmentShader));
		c.attachShader(J.program, ca("vertex", THREE.ShaderLib.lensFlareVertexTexture.vertexShader))
	}
	c.linkProgram(J.program);
	J.attributes = {};
	J.uniforms = {};
	J.attributes.vertex = c.getAttribLocation(J.program, "position");
	J.attributes.uv = c.getAttribLocation(J.program, "UV");
	J.uniforms.renderType =
		c.getUniformLocation(J.program, "renderType");
	J.uniforms.map = c.getUniformLocation(J.program, "map");
	J.uniforms.occlusionMap = c.getUniformLocation(J.program, "occlusionMap");
	J.uniforms.opacity = c.getUniformLocation(J.program, "opacity");
	J.uniforms.scale = c.getUniformLocation(J.program, "scale");
	J.uniforms.rotation = c.getUniformLocation(J.program, "rotation");
	J.uniforms.screenPosition = c.getUniformLocation(J.program, "screenPosition");
	var pb = !1;
	_sprite = {};
	_sprite.vertices = new Float32Array(16);
	_sprite.faces = new Uint16Array(6);
	b = 0;
	_sprite.vertices[b++] = -1;
	_sprite.vertices[b++] = -1;
	_sprite.vertices[b++] = 0;
	_sprite.vertices[b++] = 0;
	_sprite.vertices[b++] = 1;
	_sprite.vertices[b++] = -1;
	_sprite.vertices[b++] = 1;
	_sprite.vertices[b++] = 0;
	_sprite.vertices[b++] = 1;
	_sprite.vertices[b++] = 1;
	_sprite.vertices[b++] = 1;
	_sprite.vertices[b++] = 1;
	_sprite.vertices[b++] = -1;
	_sprite.vertices[b++] = 1;
	_sprite.vertices[b++] = 0;
	_sprite.vertices[b++] = 1;
	b = 0;
	_sprite.faces[b++] = 0;
	_sprite.faces[b++] = 1;
	_sprite.faces[b++] = 2;
	_sprite.faces[b++] = 0;
	_sprite.faces[b++] = 2;
	_sprite.faces[b++] = 3;
	_sprite.vertexBuffer = c.createBuffer();
	_sprite.elementBuffer = c.createBuffer();
	c.bindBuffer(c.ARRAY_BUFFER, _sprite.vertexBuffer);
	c.bufferData(c.ARRAY_BUFFER, _sprite.vertices, c.STATIC_DRAW);
	c.bindBuffer(c.ELEMENT_ARRAY_BUFFER, _sprite.elementBuffer);
	c.bufferData(c.ELEMENT_ARRAY_BUFFER, _sprite.faces, c.STATIC_DRAW);
	_sprite.program = c.createProgram();
	c.attachShader(_sprite.program, ca("fragment", THREE.ShaderLib.sprite.fragmentShader));
	c.attachShader(_sprite.program, ca("vertex", THREE.ShaderLib.sprite.vertexShader));
	c.linkProgram(_sprite.program);
	_sprite.attributes = {};
	_sprite.uniforms = {};
	_sprite.attributes.position = c.getAttribLocation(_sprite.program, "position");
	_sprite.attributes.uv = c.getAttribLocation(_sprite.program, "uv");
	_sprite.uniforms.uvOffset = c.getUniformLocation(_sprite.program, "uvOffset");
	_sprite.uniforms.uvScale = c.getUniformLocation(_sprite.program, "uvScale");
	_sprite.uniforms.rotation = c.getUniformLocation(_sprite.program, "rotation");
	_sprite.uniforms.scale = c.getUniformLocation(_sprite.program, "scale");
	_sprite.uniforms.alignment = c.getUniformLocation(_sprite.program, "alignment");
	_sprite.uniforms.map = c.getUniformLocation(_sprite.program, "map");
	_sprite.uniforms.opacity = c.getUniformLocation(_sprite.program, "opacity");
	_sprite.uniforms.useScreenCoordinates = c.getUniformLocation(_sprite.program, "useScreenCoordinates");
	_sprite.uniforms.affectedByDistance = c.getUniformLocation(_sprite.program, "affectedByDistance");
	_sprite.uniforms.screenPosition = c.getUniformLocation(_sprite.program, "screenPosition");
	_sprite.uniforms.modelViewMatrix =
		c.getUniformLocation(_sprite.program, "modelViewMatrix");
	_sprite.uniforms.projectionMatrix = c.getUniformLocation(_sprite.program, "projectionMatrix");
	var ob = !1;
	this.setSize = function(f, s) {
		S.width = f;
		S.height = s;
		this.setViewport(0, 0, S.width, S.height)
	};
	this.setViewport = function(f, s, j, k) {
		wa = f;
		qa = s;
		ya = j;
		za = k;
		c.viewport(wa, qa, ya, za)
	};
	this.setScissor = function(f, s, j, k) {
		c.scissor(f, s, j, k)
	};
	this.enableScissorTest = function(f) {
		f ? c.enable(c.SCISSOR_TEST) : c.disable(c.SCISSOR_TEST)
	};
	this.enableDepthBufferWrite = function(f) {
		ta =
			f;
		c.depthMask(f)
	};
	this.setClearColorHex = function(f, s) {
		var j = new THREE.Color(f);
		c.clearColor(j.r, j.g, j.b, s)
	};
	this.setClearColor = function(f, s) {
		c.clearColor(f.r, f.g, f.b, s)
	};
	this.clear = function() {
		c.clear(c.COLOR_BUFFER_BIT | c.DEPTH_BUFFER_BIT | c.STENCIL_BUFFER_BIT)
	};
	this.setStencilShadowDarkness = function(f) {
		R.darkness = f
	};
	this.initMaterial = function(f, s, j, k) {
		var m, w, x;
		if(f instanceof THREE.MeshDepthMaterial) x = "depth";
		else if(f instanceof THREE.ShadowVolumeDynamicMaterial) x = "shadowVolumeDynamic";
		else if(f instanceof THREE.MeshNormalMaterial) x = "normal";
		else if(f instanceof THREE.MeshBasicMaterial) x = "basic";
		else if(f instanceof THREE.MeshLambertMaterial) x = "lambert";
		else if(f instanceof THREE.MeshPhongMaterial) x = "phong";
		else if(f instanceof THREE.LineBasicMaterial) x = "basic";
		else f instanceof THREE.ParticleBasicMaterial && (x = "particle_basic");
		if(x) {
			var u = THREE.ShaderLib[x];
			f.uniforms = THREE.UniformsUtils.clone(u.uniforms);
			f.vertexShader = u.vertexShader;
			f.fragmentShader = u.fragmentShader
		}
		var A, t, y;
		A = y = u = 0;
		for(t = s.length; A <
			t; A++) {
			w = s[A];
			w instanceof THREE.DirectionalLight && y++;
			w instanceof THREE.PointLight && u++
		}
		if(u + y <= 4) s = y;
		else {
			s = Math.ceil(4 * y / (u + y));
			u = 4 - s
		}
		w = {
			directional: s,
			point: u
		};
		y = 50;
		if(k !== undefined && k instanceof THREE.SkinnedMesh) y = k.bones.length;
		var z;
		a: {
			A = f.fragmentShader;t = f.vertexShader;u = f.uniforms;s = f.attributes;j = {
				map: !!f.map,
				envMap: !!f.envMap,
				lightMap: !!f.lightMap,
				vertexColors: f.vertexColors,
				fog: j,
				sizeAttenuation: f.sizeAttenuation,
				skinning: f.skinning,
				morphTargets: f.morphTargets,
				maxMorphTargets: this.maxMorphTargets,
				maxDirLights: w.directional,
				maxPointLights: w.point,
				maxBones: y
			};
			var D;w = [];
			if(x) w.push(x);
			else {
				w.push(A);
				w.push(t)
			}
			for(D in j) {
				w.push(D);
				w.push(j[D])
			}
			x = w.join();D = 0;
			for(w = pa.length; D < w; D++)
				if(pa[D].code == x) {
					z = pa[D].program;
					break a
				}
			D = c.createProgram();prefix_fragment = ["#ifdef GL_ES\nprecision highp float;\n#endif", "#define MAX_DIR_LIGHTS " + j.maxDirLights, "#define MAX_POINT_LIGHTS " + j.maxPointLights, j.fog ? "#define USE_FOG" : "", j.fog instanceof THREE.FogExp2 ? "#define FOG_EXP2" : "", j.map ? "#define USE_MAP" :
				"", j.envMap ? "#define USE_ENVMAP" : "", j.lightMap ? "#define USE_LIGHTMAP" : "", j.vertexColors ? "#define USE_COLOR" : "", "uniform mat4 viewMatrix;\nuniform vec3 cameraPosition;\n"
			].join("\n");prefix_vertex = [c.getParameter(c.MAX_VERTEX_TEXTURE_IMAGE_UNITS) > 0 ? "#define VERTEX_TEXTURES" : "", "#define MAX_DIR_LIGHTS " + j.maxDirLights, "#define MAX_POINT_LIGHTS " + j.maxPointLights, "#define MAX_BONES " + j.maxBones, j.map ? "#define USE_MAP" : "", j.envMap ? "#define USE_ENVMAP" : "", j.lightMap ? "#define USE_LIGHTMAP" : "", j.vertexColors ?
				"#define USE_COLOR" : "", j.skinning ? "#define USE_SKINNING" : "", j.morphTargets ? "#define USE_MORPHTARGETS" : "", j.sizeAttenuation ? "#define USE_SIZEATTENUATION" : "", "uniform mat4 objectMatrix;\nuniform mat4 modelViewMatrix;\nuniform mat4 projectionMatrix;\nuniform mat4 viewMatrix;\nuniform mat3 normalMatrix;\nuniform vec3 cameraPosition;\nuniform mat4 cameraInverseMatrix;\nattribute vec3 position;\nattribute vec3 normal;\nattribute vec2 uv;\nattribute vec2 uv2;\n#ifdef USE_COLOR\nattribute vec3 color;\n#endif\n#ifdef USE_MORPHTARGETS\nattribute vec3 morphTarget0;\nattribute vec3 morphTarget1;\nattribute vec3 morphTarget2;\nattribute vec3 morphTarget3;\nattribute vec3 morphTarget4;\nattribute vec3 morphTarget5;\nattribute vec3 morphTarget6;\nattribute vec3 morphTarget7;\n#endif\n#ifdef USE_SKINNING\nattribute vec4 skinVertexA;\nattribute vec4 skinVertexB;\nattribute vec4 skinIndex;\nattribute vec4 skinWeight;\n#endif\n"
			].join("\n");
			c.attachShader(D, ca("fragment", prefix_fragment + A));c.attachShader(D, ca("vertex", prefix_vertex + t));c.linkProgram(D);c.getProgramParameter(D, c.LINK_STATUS) || console.error("Could not initialise shader\nVALIDATE_STATUS: " + c.getProgramParameter(D, c.VALIDATE_STATUS) + ", gl error [" + c.getError() + "]");D.uniforms = {};D.attributes = {};
			var B;A = ["viewMatrix", "modelViewMatrix", "projectionMatrix", "normalMatrix", "objectMatrix", "cameraPosition", "cameraInverseMatrix", "boneGlobalMatrices", "morphTargetInfluences"];
			for(B in u) A.push(B);
			B = A;u = 0;
			for(A = B.length; u < A; u++) {
				t = B[u];
				D.uniforms[t] = c.getUniformLocation(D, t)
			}
			A = ["position", "normal", "uv", "uv2", "tangent", "color", "skinVertexA", "skinVertexB", "skinIndex", "skinWeight"];
			for(B = 0; B < j.maxMorphTargets; B++) A.push("morphTarget" + B);
			for(z in s) A.push(z);z = A;B = 0;
			for(s = z.length; B < s; B++) {
				j = z[B];
				D.attributes[j] = c.getAttribLocation(D, j)
			}
			pa.push({
				program: D,
				code: x
			});z = D
		}
		f.program = z;
		z = f.program.attributes;
		c.enableVertexAttribArray(z.position);
		z.color >= 0 && c.enableVertexAttribArray(z.color);
		z.normal >=
			0 && c.enableVertexAttribArray(z.normal);
		z.tangent >= 0 && c.enableVertexAttribArray(z.tangent);
		if(f.skinning && z.skinVertexA >= 0 && z.skinVertexB >= 0 && z.skinIndex >= 0 && z.skinWeight >= 0) {
			c.enableVertexAttribArray(z.skinVertexA);
			c.enableVertexAttribArray(z.skinVertexB);
			c.enableVertexAttribArray(z.skinIndex);
			c.enableVertexAttribArray(z.skinWeight)
		}
		for(m in f.attributes) z[m] >= 0 && c.enableVertexAttribArray(z[m]);
		if(f.morphTargets) {
			f.numSupportedMorphTargets = 0;
			if(z.morphTarget0 >= 0) {
				c.enableVertexAttribArray(z.morphTarget0);
				f.numSupportedMorphTargets++
			}
			if(z.morphTarget1 >= 0) {
				c.enableVertexAttribArray(z.morphTarget1);
				f.numSupportedMorphTargets++
			}
			if(z.morphTarget2 >= 0) {
				c.enableVertexAttribArray(z.morphTarget2);
				f.numSupportedMorphTargets++
			}
			if(z.morphTarget3 >= 0) {
				c.enableVertexAttribArray(z.morphTarget3);
				f.numSupportedMorphTargets++
			}
			if(z.morphTarget4 >= 0) {
				c.enableVertexAttribArray(z.morphTarget4);
				f.numSupportedMorphTargets++
			}
			if(z.morphTarget5 >= 0) {
				c.enableVertexAttribArray(z.morphTarget5);
				f.numSupportedMorphTargets++
			}
			if(z.morphTarget6 >=
				0) {
				c.enableVertexAttribArray(z.morphTarget6);
				f.numSupportedMorphTargets++
			}
			if(z.morphTarget7 >= 0) {
				c.enableVertexAttribArray(z.morphTarget7);
				f.numSupportedMorphTargets++
			}
			k.__webglMorphTargetInfluences = new Float32Array(this.maxMorphTargets);
			f = 0;
			for(m = this.maxMorphTargets; f < m; f++) k.__webglMorphTargetInfluences[f] = 0
		}
	};
	this.render = function(f, s, j, k) {
		var m, w, x, u, A, t, y, z, D = f.lights,
			B = f.fog;
		s.matrixAutoUpdate && s.updateMatrix();
		f.update(undefined, !1, s);
		s.matrixWorldInverse.flattenToArray(Xa);
		s.projectionMatrix.flattenToArray(Ta);
		Pa.multiply(s.projectionMatrix, s.matrixWorldInverse);
		p(Pa);
		this.initWebGLObjects(f);
		Ia(j);
		(this.autoClear || k) && this.clear();
		A = f.__webglObjects.length;
		for(k = 0; k < A; k++) {
			m = f.__webglObjects[k];
			y = m.object;
			if(y.visible)
				if(!(y instanceof THREE.Mesh) || q(y)) {
					y.matrixWorld.flattenToArray(y._objectMatrixArray);
					V(y, s);
					F(m);
					m.render = !0;
					if(this.sortObjects) {
						Ua.copy(y.position);
						Pa.multiplyVector3(Ua);
						m.z = Ua.z
					}
				} else m.render = !1;
			else m.render = !1
		}
		this.sortObjects && f.__webglObjects.sort(H);
		t = f.__webglObjectsImmediate.length;
		for(k = 0; k < t; k++) {
			m = f.__webglObjectsImmediate[k];
			y = m.object;
			if(y.visible) {
				y.matrixAutoUpdate && y.matrixWorld.flattenToArray(y._objectMatrixArray);
				V(y, s);
				E(m)
			}
		}
		oa(THREE.NormalBlending);
		for(k = 0; k < A; k++) {
			m = f.__webglObjects[k];
			if(m.render) {
				y = m.object;
				z = m.buffer;
				x = m.opaque;
				o(y);
				for(m = 0; m < x.count; m++) {
					u = x.list[m];
					n(u.depthTest);
					g(s, D, B, u, z, y)
				}
			}
		}
		for(k = 0; k < t; k++) {
			m = f.__webglObjectsImmediate[k];
			y = m.object;
			if(y.visible) {
				x = m.opaque;
				o(y);
				for(m = 0; m < x.count; m++) {
					u = x.list[m];
					n(u.depthTest);
					w = e(s, D, B, u, y);
					y.render(function(O) {
						h(O,
							w, u.shading)
					})
				}
			}
		}
		for(k = 0; k < A; k++) {
			m = f.__webglObjects[k];
			if(m.render) {
				y = m.object;
				z = m.buffer;
				x = m.transparent;
				o(y);
				for(m = 0; m < x.count; m++) {
					u = x.list[m];
					oa(u.blending);
					n(u.depthTest);
					g(s, D, B, u, z, y)
				}
			}
		}
		for(k = 0; k < t; k++) {
			m = f.__webglObjectsImmediate[k];
			y = m.object;
			if(y.visible) {
				x = m.transparent;
				o(y);
				for(m = 0; m < x.count; m++) {
					u = x.list[m];
					oa(u.blending);
					n(u.depthTest);
					w = e(s, D, B, u, y);
					y.render(function(O) {
						h(O, w, u.shading)
					})
				}
			}
		}
		f.__webglSprites.length && M(f, s);
		stencil && f.__webglShadowVolumes.length && f.lights.length && I(f);
		f.__webglLensFlares.length && N(f, s);
		if(j && j.minFilter !== THREE.NearestFilter && j.minFilter !== THREE.LinearFilter) {
			c.bindTexture(c.TEXTURE_2D, j.__webglTexture);
			c.generateMipmap(c.TEXTURE_2D);
			c.bindTexture(c.TEXTURE_2D, null)
		}
	};
	this.initWebGLObjects = function(f) {
		if(!f.__webglObjects) {
			f.__webglObjects = [];
			f.__webglObjectsImmediate = [];
			f.__webglShadowVolumes = [];
			f.__webglLensFlares = [];
			f.__webglSprites = []
		}
		for(; f.__objectsAdded.length;) {
			var s = f.__objectsAdded[0],
				j = f,
				k = void 0,
				m = void 0,
				w = void 0;
			if(s._modelViewMatrix ==
				undefined) {
				s._modelViewMatrix = new THREE.Matrix4;
				s._normalMatrixArray = new Float32Array(9);
				s._modelViewMatrixArray = new Float32Array(16);
				s._objectMatrixArray = new Float32Array(16);
				s.matrixWorld.flattenToArray(s._objectMatrixArray)
			}
			if(s instanceof THREE.Mesh) {
				m = s.geometry;
				m.geometryGroups == undefined && sa(m);
				for(k in m.geometryGroups) {
					w = m.geometryGroups[k];
					if(!w.__webglVertexBuffer) {
						var x = w;
						x.__webglVertexBuffer = c.createBuffer();
						x.__webglNormalBuffer = c.createBuffer();
						x.__webglTangentBuffer = c.createBuffer();
						x.__webglColorBuffer = c.createBuffer();
						x.__webglUVBuffer = c.createBuffer();
						x.__webglUV2Buffer = c.createBuffer();
						x.__webglSkinVertexABuffer = c.createBuffer();
						x.__webglSkinVertexBBuffer = c.createBuffer();
						x.__webglSkinIndicesBuffer = c.createBuffer();
						x.__webglSkinWeightsBuffer = c.createBuffer();
						x.__webglFaceBuffer = c.createBuffer();
						x.__webglLineBuffer = c.createBuffer();
						if(x.numMorphTargets) {
							var u = void 0,
								A = void 0;
							x.__webglMorphTargetsBuffers = [];
							u = 0;
							for(A = x.numMorphTargets; u < A; u++) x.__webglMorphTargetsBuffers.push(c.createBuffer())
						}
						x =
							w;
						u = s;
						var t = void 0,
							y = void 0,
							z = void 0;
						z = void 0;
						var D = void 0,
							B = void 0,
							O = void 0,
							W = O = A = 0;
						y = void 0;
						z = void 0;
						var P = void 0;
						t = void 0;
						y = void 0;
						D = u.geometry;
						P = D.faces;
						B = x.faces;
						t = 0;
						for(y = B.length; t < y; t++) {
							z = B[t];
							z = P[z];
							if(z instanceof THREE.Face3) {
								A += 3;
								O += 1;
								W += 3
							} else if(z instanceof THREE.Face4) {
								A += 4;
								O += 2;
								W += 4
							}
						}
						t = x;
						y = u;
						P = void 0;
						B = void 0;
						var X = void 0,
							Ga = void 0;
						X = void 0;
						z = [];
						P = 0;
						for(B = y.materials.length; P < B; P++) {
							X = y.materials[P];
							if(X instanceof THREE.MeshFaceMaterial) {
								X = 0;
								for(l = t.materials.length; X < l; X++)(Ga =
									t.materials[X]) && z.push(Ga)
							} else(Ga = X) && z.push(Ga)
						}
						t = z;
						a: {
							y = void 0;P = void 0;B = t.length;
							for(y = 0; y < B; y++) {
								P = t[y];
								if(P.map || P.lightMap || P instanceof THREE.MeshShaderMaterial) {
									y = !0;
									break a
								}
							}
							y = !1
						}
						a: {
							P = void 0;B = void 0;z = t.length;
							for(P = 0; P < z; P++) {
								B = t[P];
								if(!(B instanceof THREE.MeshBasicMaterial && !B.envMap || B instanceof THREE.MeshDepthMaterial)) {
									P = B && B.shading != undefined && B.shading == THREE.SmoothShading ? THREE.SmoothShading : THREE.FlatShading;
									break a
								}
							}
							P = !1
						}
						a: {
							B = void 0;z = void 0;X = t.length;
							for(B = 0; B < X; B++) {
								z =
									t[B];
								if(z.vertexColors) {
									z = z.vertexColors;
									break a
								}
							}
							z = !1
						}
						x.__vertexArray = new Float32Array(A * 3);
						if(P) x.__normalArray = new Float32Array(A * 3);
						if(D.hasTangents) x.__tangentArray = new Float32Array(A * 4);
						if(z) x.__colorArray = new Float32Array(A * 3);
						if(y) {
							if(D.faceUvs.length > 0 || D.faceVertexUvs.length > 0) x.__uvArray = new Float32Array(A * 2);
							if(D.faceUvs.length > 1 || D.faceVertexUvs.length > 1) x.__uv2Array = new Float32Array(A * 2)
						}
						if(u.geometry.skinWeights.length && u.geometry.skinIndices.length) {
							x.__skinVertexAArray = new Float32Array(A *
								4);
							x.__skinVertexBArray = new Float32Array(A * 4);
							x.__skinIndexArray = new Float32Array(A * 4);
							x.__skinWeightArray = new Float32Array(A * 4)
						}
						x.__faceArray = new Uint16Array(O * 3 + (u.geometry.edgeFaces ? u.geometry.edgeFaces.length * 6 : 0));
						x.__lineArray = new Uint16Array(W * 2);
						if(x.numMorphTargets) {
							x.__morphTargetsArrays = [];
							D = 0;
							for(B = x.numMorphTargets; D < B; D++) x.__morphTargetsArrays.push(new Float32Array(A * 3))
						}
						x.__needsSmoothNormals = P == THREE.SmoothShading;
						x.__uvType = y;
						x.__vertexColorType = z;
						x.__normalType = P;
						x.__webglFaceCount =
							O * 3 + (u.geometry.edgeFaces ? u.geometry.edgeFaces.length * 6 : 0);
						x.__webglLineCount = W * 2;
						D = 0;
						for(B = t.length; D < B; D++)
							if(t[D].attributes) {
								x.__webglCustomAttributes = {};
								for(a in t[D].attributes) {
									y = t[D].attributes[a];
									O = 1;
									if(y.type === "v2") O = 2;
									else if(y.type === "v3") O = 3;
									else if(y.type === "v4") O = 4;
									else y.type === "c" && (O = 3);
									y.size = O;
									y.needsUpdate = !0;
									y.array = new Float32Array(A * O);
									y.buffer = c.createBuffer();
									x.__webglCustomAttributes[a] = y
								}
							}
						m.__dirtyVertices = !0;
						m.__dirtyMorphTargets = !0;
						m.__dirtyElements = !0;
						m.__dirtyUvs = !0;
						m.__dirtyNormals = !0;
						m.__dirtyTangents = !0;
						m.__dirtyColors = !0
					}
					s instanceof THREE.ShadowVolume ? da(j.__webglShadowVolumes, w, s) : da(j.__webglObjects, w, s)
				}
			} else if(s instanceof THREE.LensFlare) da(j.__webglLensFlares, undefined, s);
			else if(s instanceof THREE.Ribbon) {
				m = s.geometry;
				if(!m.__webglVertexBuffer) {
					k = m;
					k.__webglVertexBuffer = c.createBuffer();
					k.__webglColorBuffer = c.createBuffer();
					k = m;
					w = k.vertices.length;
					k.__vertexArray = new Float32Array(w * 3);
					k.__colorArray = new Float32Array(w * 3);
					k.__webglVertexCount =
						w;
					m.__dirtyVertices = !0;
					m.__dirtyColors = !0
				}
				da(j.__webglObjects, m, s)
			} else if(s instanceof THREE.Line) {
				m = s.geometry;
				if(!m.__webglVertexBuffer) {
					k = m;
					k.__webglVertexBuffer = c.createBuffer();
					k.__webglColorBuffer = c.createBuffer();
					k = m;
					w = k.vertices.length;
					k.__vertexArray = new Float32Array(w * 3);
					k.__colorArray = new Float32Array(w * 3);
					k.__webglLineCount = w;
					m.__dirtyVertices = !0;
					m.__dirtyColors = !0
				}
				da(j.__webglObjects, m, s)
			} else if(s instanceof THREE.ParticleSystem) {
				m = s.geometry;
				if(!m.__webglVertexBuffer) {
					k = m;
					k.__webglVertexBuffer =
						c.createBuffer();
					k.__webglColorBuffer = c.createBuffer();
					k = m;
					w = k.vertices.length;
					k.__vertexArray = new Float32Array(w * 3);
					k.__colorArray = new Float32Array(w * 3);
					k.__sortArray = [];
					k.__webglParticleCount = w;
					m.__dirtyVertices = !0;
					m.__dirtyColors = !0
				}
				da(j.__webglObjects, m, s)
			} else if(THREE.MarchingCubes !== undefined && s instanceof THREE.MarchingCubes) j.__webglObjectsImmediate.push({
				object: s,
				opaque: {
					list: [],
					count: 0
				},
				transparent: {
					list: [],
					count: 0
				}
			});
			else s instanceof THREE.Sprite && j.__webglSprites.push(s);
			f.__objectsAdded.splice(0,
				1)
		}
		for(; f.__objectsRemoved.length;) {
			s = f.__objectsRemoved[0];
			j = f;
			m = void 0;
			k = void 0;
			for(m = j.__webglObjects.length - 1; m >= 0; m--) {
				k = j.__webglObjects[m].object;
				if(s == k) {
					j.__webglObjects.splice(m, 1);
					break
				}
			}
			f.__objectsRemoved.splice(0, 1)
		}
		s = 0;
		for(j = f.__webglObjects.length; s < j; s++) L(f.__webglObjects[s].object, f);
		s = 0;
		for(j = f.__webglShadowVolumes.length; s < j; s++) L(f.__webglShadowVolumes[s].object, f);
		s = 0;
		for(j = f.__webglLensFlares.length; s < j; s++) L(f.__webglLensFlares[s].object, f)
	};
	this.setFaceCulling = function(f,
		s) {
		if(f) {
			!s || s == "ccw" ? c.frontFace(c.CCW) : c.frontFace(c.CW);
			if(f == "back") c.cullFace(c.BACK);
			else f == "front" ? c.cullFace(c.FRONT) : c.cullFace(c.FRONT_AND_BACK);
			c.enable(c.CULL_FACE)
		} else c.disable(c.CULL_FACE)
	};
	this.supportsVertexTextures = function() {
		return c.getParameter(c.MAX_VERTEX_TEXTURE_IMAGE_UNITS) > 0
	}
};
THREE.WebGLRenderTarget = function(b, d, e) {
	this.width = b;
	this.height = d;
	e = e || {};
	this.wrapS = e.wrapS !== undefined ? e.wrapS : THREE.ClampToEdgeWrapping;
	this.wrapT = e.wrapT !== undefined ? e.wrapT : THREE.ClampToEdgeWrapping;
	this.magFilter = e.magFilter !== undefined ? e.magFilter : THREE.LinearFilter;
	this.minFilter = e.minFilter !== undefined ? e.minFilter : THREE.LinearMipMapLinearFilter;
	this.format = e.format !== undefined ? e.format : THREE.RGBAFormat;
	this.type = e.type !== undefined ? e.type : THREE.UnsignedByteType;
	this.depthBuffer = e.depthBuffer !==
		undefined ? e.depthBuffer : !0;
	this.stencilBuffer = e.stencilBuffer !== undefined ? e.stencilBuffer : !0
};